harmony-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Tim Ellison <t.p.elli...@gmail.com>
Subject Re: svn commit: r421111 [1/11] - in /incubator/harmony/enhanced/classlib/trunk/sandbox: ./ juc-proposal/ juc-proposal/concurrent/ juc-proposal/concurrent/.settings/ juc-proposal/concurrent/META-INF/ juc-proposal/concurrent/src/ juc-proposal/concurrent/src/...
Date Wed, 12 Jul 2006 08:24:04 GMT
-1 for this commit.

I'll discuss over on the concurrent utils thread:
http://mail-archives.apache.org/mod_mbox/incubator-harmony-dev/200607.mbox/%3c005401c6a56e$79234ce0$0c01a8c0@LITTLEGUY%3e

Regards,
Tim

ndbeyer@apache.org wrote:
> Author: ndbeyer
> Date: Tue Jul 11 21:12:04 2006
> New Revision: 421111
> 
> URL: http://svn.apache.org/viewvc?rev=421111&view=rev
> Log:
> Check in java.util.concurrent module proposal.
> 
> Added:
>     incubator/harmony/enhanced/classlib/trunk/sandbox/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent.tar.gz   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.project   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.core.prefs
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.ui.prefs
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.pde.core.prefs
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/META-INF/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/META-INF/MANIFEST.MF
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ConcurrentHashMap.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ConcurrentMap.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CopyOnWriteArraySet.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CountDownLatch.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CyclicBarrier.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/DelayQueue.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Delayed.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Exchanger.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ExecutionException.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Executor.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ExecutorCompletionService.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ExecutorService.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Executors.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Future.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/FutureTask.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/LinkedBlockingQueue.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/PriorityBlockingQueue.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/RejectedExecutionException.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/RejectedExecutionHandler.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ScheduledExecutorService.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ScheduledFuture.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ScheduledThreadPoolExecutor.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Semaphore.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/SynchronousQueue.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ThreadFactory.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ThreadPoolExecutor.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/TimeUnit.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/TimeoutException.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicBoolean.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicInteger.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicIntegerArray.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLong.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLongArray.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLongFieldUpdater.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicMarkableReference.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReference.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReferenceArray.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/AtomicStampedReference.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/atomic/package.html   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/Condition.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/Lock.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/LockSupport.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/ReadWriteLock.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/ReentrantLock.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/locks/package.html   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/package.html   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/harmony/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/harmony/concurrent/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/harmony/concurrent/AtomicSupport.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/harmony/concurrent/LocksSupport.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/org/apache/harmony/concurrent/ServiceLoader.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/resources/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/harmony/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/harmony/concurrent/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/harmony/concurrent/ServiceA.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/harmony/concurrent/ServiceAImpl.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/java/org/apache/harmony/concurrent/ServiceLoaderTest.java   (with props)
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/resources/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/resources/META-INF/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/resources/META-INF/services/
>     incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/test/resources/META-INF/services/org.apache.harmony.concurrent.ServiceA
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,22 @@
> +README
> +======
> +
> +
> +This directory contains the proposed contents and layout of the 'concurrent' module
> +for the Apache Harmony Class Library. The majority of the source code is from Doug
> +Lea's Concurrency JSR-166 Interest Site [1].
> +
> +
> +Contents
> +--------
> +
> +*  concurrent        - The 'concurrent' module that will eventually end up at 
> +                       https://svn.apache.org/repos/asf/incubator/harmony/enhanced/classlib/trunk/modules/concurrent
> +
> +*  concurrent.tar.gz - The TAR ball of the original source, as pulled from Doub 
> +                       Lea's ViewCVS. The source was pulled from the site at the
> +                       tag JSR166_PFD [2].
> +
> +
> +[1] http://gee.cs.oswego.edu/dl/concurrency-interest/
> +[2] http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/main/java/util/concurrent/?only_with_tag=JSR166_PFD
> \ No newline at end of file
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/README.txt
> ------------------------------------------------------------------------------
>     svn:eol-style = native
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/
> ------------------------------------------------------------------------------
> --- svn:ignore (added)
> +++ svn:ignore Tue Jul 11 21:12:04 2006
> @@ -0,0 +1 @@
> +target
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent.tar.gz
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent.tar.gz?rev=421111&view=auto
> ==============================================================================
> Binary file - no diff available.
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent.tar.gz
> ------------------------------------------------------------------------------
>     svn:mime-type = application/octet-stream
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,10 @@
> +<?xml version="1.0" encoding="UTF-8"?>
> +<classpath>
> +	<classpathentry output="target/classes" kind="src" path="src/main/java"/>
> +	<classpathentry output="target/classes" kind="src" path="src/main/resources"/>
> +	<classpathentry output="target/test-classes" kind="src" path="src/test/java"/>
> +	<classpathentry output="target/test-classes" kind="src" path="src/test/resources"/>
> +	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
> +	<classpathentry sourcepath="JUNIT_SRC_HOME/junitsrc.zip" kind="var" path="JUNIT_HOME/junit.jar"/>
> +	<classpathentry kind="output" path="target/classes"/>
> +</classpath>
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.classpath
> ------------------------------------------------------------------------------
>     svn:eol-style = native
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.project
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.project?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.project (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.project Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,28 @@
> +<?xml version="1.0" encoding="UTF-8"?>
> +<projectDescription>
> +	<name>concurrent</name>
> +	<comment></comment>
> +	<projects>
> +	</projects>
> +	<buildSpec>
> +		<buildCommand>
> +			<name>org.eclipse.jdt.core.javabuilder</name>
> +			<arguments>
> +			</arguments>
> +		</buildCommand>
> +		<buildCommand>
> +			<name>org.eclipse.pde.ManifestBuilder</name>
> +			<arguments>
> +			</arguments>
> +		</buildCommand>
> +		<buildCommand>
> +			<name>org.eclipse.pde.SchemaBuilder</name>
> +			<arguments>
> +			</arguments>
> +		</buildCommand>
> +	</buildSpec>
> +	<natures>
> +		<nature>org.eclipse.pde.PluginNature</nature>
> +		<nature>org.eclipse.jdt.core.javanature</nature>
> +	</natures>
> +</projectDescription>
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.project
> ------------------------------------------------------------------------------
>     svn:eol-style = native
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.core.prefs
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.core.prefs?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.core.prefs (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.core.prefs Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,12 @@
> +#Wed May 03 13:10:22 BST 2006
> +eclipse.preferences.version=1
> +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
> +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4
> +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
> +org.eclipse.jdt.core.compiler.compliance=1.5
> +org.eclipse.jdt.core.compiler.debug.lineNumber=generate
> +org.eclipse.jdt.core.compiler.debug.localVariable=generate
> +org.eclipse.jdt.core.compiler.debug.sourceFile=generate
> +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
> +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
> +org.eclipse.jdt.core.compiler.source=1.5
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.ui.prefs
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.ui.prefs?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.ui.prefs (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.jdt.ui.prefs Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,3 @@
> +#Wed May 03 13:10:00 BST 2006
> +eclipse.preferences.version=1
> +internal.default.compliance=user
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.pde.core.prefs
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.pde.core.prefs?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.pde.core.prefs (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/.settings/org.eclipse.pde.core.prefs Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,3 @@
> +#Thu Dec 15 00:50:33 GMT 2005
> +eclipse.preferences.version=1
> +pluginProject.extensions=false
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/META-INF/MANIFEST.MF
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/META-INF/MANIFEST.MF?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/META-INF/MANIFEST.MF (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/META-INF/MANIFEST.MF Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,18 @@
> +Manifest-Version: 1.0
> +Bundle-ManifestVersion: 2
> +Bundle-Name: Harmony Concurrent
> +Bundle-SymbolicName: org.apache.harmony.concurrent
> +Bundle-Version: 1.0.0
> +Bundle-ClassPath: .
> +Eclipse-JREBundle: true
> +Import-Package: 
> + java.io,
> + java.lang,
> + java.lang.reflect,
> + java.net,
> + java.security,
> + java.util
> +Export-Package: java.util.concurrent,
> + java.util.concurrent.atomic,
> + java.util.concurrent.locks,
> + org.apache.harmony.concurrent
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,57 @@
> +<project xmlns="http://maven.apache.org/POM/4.0.0"
> +	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
> +	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
> +	<modelVersion>4.0.0</modelVersion>
> +	<groupId>org.apache.harmony</groupId>
> +	<artifactId>concurrent</artifactId>
> +	<packaging>jar</packaging>
> +	<version>1.0-SNAPSHOT</version>
> +	<name>Apache Harmony Class Library Concurrent Module</name>
> +	<url>http://incubator.apache.org/harmony/</url>
> +	<build>
> +		<plugins>
> +			<plugin>
> +				<artifactId>maven-compiler-plugin</artifactId>
> +				<configuration>
> +					<source>1.5</source>
> +					<target>1.5</target>
> +				</configuration>
> +			</plugin>
> +			<plugin>
> +				<artifactId>maven-jar-plugin</artifactId>
> +				<configuration>
> +					<archive>
> +						<manifestFile>
> +							META-INF/MANIFEST.MF
> +						</manifestFile>
> +					</archive>
> +				</configuration>
> +			</plugin>
> +		</plugins>
> +	</build>
> +	<reporting>
> +		<plugins>
> +			<plugin>
> +				<artifactId>maven-surefire-report-plugin</artifactId>
> +			</plugin>
> +			<plugin>
> +				<artifactId>maven-javadoc-plugin</artifactId>
> +				<configuration>
> +					<source>1.5</source>
> +					<show>private</show>
> +				</configuration>
> +			</plugin>
> +			<plugin>
> +				<artifactId>maven-jxr-plugin</artifactId>
> +			</plugin>
> +		</plugins>
> +	</reporting>
> +	<dependencies>
> +		<dependency>
> +			<groupId>junit</groupId>
> +			<artifactId>junit</artifactId>
> +			<version>[3,4)</version>
> +			<scope>test</scope>
> +		</dependency>
> +	</dependencies>
> +</project>
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/pom.xml
> ------------------------------------------------------------------------------
>     svn:eol-style = native
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,223 @@
> +/*
> + * Written by Doug Lea with assistance from members of JCP JSR-166
> + * Expert Group and released to the public domain, as explained at
> + * http://creativecommons.org/licenses/publicdomain
> + */
> +
> +package java.util.concurrent;
> +
> +import java.util.*;
> +
> +/**
> + * Provides default implementation of {@link ExecutorService}
> + * execution methods. This class implements the <tt>submit</tt>,
> + * <tt>invokeAny</tt> and <tt>invokeAll</tt> methods using the default
> + * {@link FutureTask} class provided in this package.  For example,
> + * the implementation of <tt>submit(Runnable)</tt> creates an
> + * associated <tt>FutureTask</tt> that is executed and
> + * returned. Subclasses overriding these methods to use different
> + * {@link Future} implementations should do so consistently for each
> + * of these methods.
> + *
> + * @since 1.5
> + * @author Doug Lea
> + */
> +public abstract class AbstractExecutorService implements ExecutorService {
> +
> +    public Future<?> submit(Runnable task) {
> +        if (task == null) throw new NullPointerException();
> +        FutureTask<Object> ftask = new FutureTask<Object>(task, null);
> +        execute(ftask);
> +        return ftask;
> +    }
> +
> +    public <T> Future<T> submit(Runnable task, T result) {
> +        if (task == null) throw new NullPointerException();
> +        FutureTask<T> ftask = new FutureTask<T>(task, result);
> +        execute(ftask);
> +        return ftask;
> +    }
> +
> +    public <T> Future<T> submit(Callable<T> task) {
> +        if (task == null) throw new NullPointerException();
> +        FutureTask<T> ftask = new FutureTask<T>(task);
> +        execute(ftask);
> +        return ftask;
> +    }
> +
> +    /**
> +     * the main mechanics of invokeAny.
> +     */
> +    private <T> T doInvokeAny(Collection<Callable<T>> tasks,
> +                            boolean timed, long nanos)
> +        throws InterruptedException, ExecutionException, TimeoutException {
> +        if (tasks == null)
> +            throw new NullPointerException();
> +        int ntasks = tasks.size();
> +        if (ntasks == 0)
> +            throw new IllegalArgumentException();
> +        List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);
> +        ExecutorCompletionService<T> ecs = 
> +            new ExecutorCompletionService<T>(this);
> +
> +        // For efficiency, especially in executors with limited
> +        // parallelism, check to see if previously submitted tasks are
> +        // done before submitting more of them. This interleaving
> +        // plus the exception mechanics account for messiness of main
> +        // loop.
> +
> +        try {
> +            // Record exceptions so that if we fail to obtain any
> +            // result, we can throw the last exception we got.
> +            ExecutionException ee = null;
> +            long lastTime = (timed)? System.nanoTime() : 0;
> +            Iterator<Callable<T>> it = tasks.iterator();
> +
> +            // Start one task for sure; the rest incrementally
> +            futures.add(ecs.submit(it.next()));
> +            --ntasks;
> +            int active = 1;
> +
> +            for (;;) {
> +                Future<T> f = ecs.poll(); 
> +                if (f == null) {
> +                    if (ntasks > 0) {
> +                        --ntasks;
> +                        futures.add(ecs.submit(it.next()));
> +                        ++active;
> +                    }
> +                    else if (active == 0) 
> +                        break;
> +                    else if (timed) {
> +                        f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
> +                        if (f == null)
> +                            throw new TimeoutException();
> +                        long now = System.nanoTime();
> +                        nanos -= now - lastTime;
> +                        lastTime = now;
> +                    }
> +                    else 
> +                        f = ecs.take();
> +                }
> +                if (f != null) {
> +                    --active;
> +                    try {
> +                        return f.get();
> +                    } catch(InterruptedException ie) {
> +                        throw ie;
> +                    } catch(ExecutionException eex) {
> +                        ee = eex;
> +                    } catch(RuntimeException rex) {
> +                        ee = new ExecutionException(rex);
> +                    }
> +                }
> +            }    
> +
> +            if (ee == null)
> +                ee = new ExecutionException();
> +            throw ee;
> +
> +        } finally {
> +            for (Future<T> f : futures) 
> +                f.cancel(true);
> +        }
> +    }
> +
> +    public <T> T invokeAny(Collection<Callable<T>> tasks)
> +        throws InterruptedException, ExecutionException {
> +        try {
> +            return doInvokeAny(tasks, false, 0);
> +        } catch (TimeoutException cannotHappen) {
> +            assert false;
> +            return null;
> +        }
> +    }
> +
> +    public <T> T invokeAny(Collection<Callable<T>> tasks, 
> +                           long timeout, TimeUnit unit) 
> +        throws InterruptedException, ExecutionException, TimeoutException {
> +        return doInvokeAny(tasks, true, unit.toNanos(timeout));
> +    }
> +
> +    public <T> List<Future<T>> invokeAll(Collection<Callable<T>> tasks)
> +        throws InterruptedException {
> +        if (tasks == null)
> +            throw new NullPointerException();
> +        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
> +        boolean done = false;
> +        try {
> +            for (Callable<T> t : tasks) {
> +                FutureTask<T> f = new FutureTask<T>(t);
> +                futures.add(f);
> +                execute(f);
> +            }
> +            for (Future<T> f : futures) {
> +                if (!f.isDone()) {
> +                    try { 
> +                        f.get(); 
> +                    } catch(CancellationException ignore) {
> +                    } catch(ExecutionException ignore) {
> +                    }
> +                }
> +            }
> +            done = true;
> +            return futures;
> +        } finally {
> +            if (!done)
> +                for (Future<T> f : futures) 
> +                    f.cancel(true);
> +        }
> +    }
> +
> +    public <T> List<Future<T>> invokeAll(Collection<Callable<T>> tasks, 
> +                                         long timeout, TimeUnit unit) 
> +        throws InterruptedException {
> +        if (tasks == null || unit == null)
> +            throw new NullPointerException();
> +        long nanos = unit.toNanos(timeout);
> +        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
> +        boolean done = false;
> +        try {
> +            for (Callable<T> t : tasks) 
> +                futures.add(new FutureTask<T>(t));
> +
> +            long lastTime = System.nanoTime();
> +
> +            // Interleave time checks and calls to execute in case
> +            // executor doesn't have any/much parallelism.
> +            Iterator<Future<T>> it = futures.iterator();
> +            while (it.hasNext()) {
> +                execute((Runnable)(it.next()));
> +                long now = System.nanoTime();
> +                nanos -= now - lastTime;
> +                lastTime = now;
> +                if (nanos <= 0)
> +                    return futures; 
> +            }
> +
> +            for (Future<T> f : futures) {
> +                if (!f.isDone()) {
> +                    if (nanos <= 0) 
> +                        return futures; 
> +                    try { 
> +                        f.get(nanos, TimeUnit.NANOSECONDS); 
> +                    } catch(CancellationException ignore) {
> +                    } catch(ExecutionException ignore) {
> +                    } catch(TimeoutException toe) {
> +                        return futures;
> +                    }
> +                    long now = System.nanoTime();
> +                    nanos -= now - lastTime;
> +                    lastTime = now;
> +                }
> +            }
> +            done = true;
> +            return futures;
> +        } finally {
> +            if (!done)
> +                for (Future<T> f : futures) 
> +                    f.cancel(true);
> +        }
> +    }
> +
> +}
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java
> ------------------------------------------------------------------------------
>     svn:eol-style = native
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,685 @@
> +/*
> + * Written by Doug Lea with assistance from members of JCP JSR-166
> + * Expert Group and released to the public domain, as explained at
> + * http://creativecommons.org/licenses/publicdomain
> + */
> +
> +package java.util.concurrent;
> +import java.util.concurrent.locks.*;
> +import java.util.*;
> +
> +/**
> + * A bounded {@linkplain BlockingQueue blocking queue} backed by an
> + * array.  This queue orders elements FIFO (first-in-first-out).  The
> + * <em>head</em> of the queue is that element that has been on the
> + * queue the longest time.  The <em>tail</em> of the queue is that
> + * element that has been on the queue the shortest time. New elements
> + * are inserted at the tail of the queue, and the queue retrieval
> + * operations obtain elements at the head of the queue.
> + *
> + * <p>This is a classic &quot;bounded buffer&quot;, in which a
> + * fixed-sized array holds elements inserted by producers and
> + * extracted by consumers.  Once created, the capacity cannot be
> + * increased.  Attempts to offer an element to a full queue will
> + * result in the offer operation blocking; attempts to retrieve an
> + * element from an empty queue will similarly block.
> + *
> + * <p> This class supports an optional fairness policy for ordering
> + * waiting producer and consumer threads.  By default, this ordering
> + * is not guaranteed. However, a queue constructed with fairness set
> + * to <tt>true</tt> grants threads access in FIFO order. Fairness
> + * generally decreases throughput but reduces variability and avoids
> + * starvation.
> + *
> + * <p>This class implements all of the <em>optional</em> methods
> + * of the {@link Collection} and {@link Iterator} interfaces.
> + *
> + * <p>This class is a member of the
> + * <a href="{@docRoot}/../guide/collections/index.html">
> + * Java Collections Framework</a>.
> + *
> + * @since 1.5
> + * @author Doug Lea
> + * @param <E> the type of elements held in this collection
> + */
> +public class ArrayBlockingQueue<E> extends AbstractQueue<E>
> +        implements BlockingQueue<E>, java.io.Serializable {
> +
> +    /**
> +     * Serialization ID. This class relies on default serialization
> +     * even for the items array, which is default-serialized, even if
> +     * it is empty. Otherwise it could not be declared final, which is
> +     * necessary here.
> +     */
> +    private static final long serialVersionUID = -817911632652898426L;
> +
> +    /** The queued items  */
> +    private final E[] items;
> +    /** items index for next take, poll or remove */
> +    private transient int takeIndex;
> +    /** items index for next put, offer, or add. */
> +    private transient int putIndex;
> +    /** Number of items in the queue */
> +    private int count;
> +
> +    /*
> +     * Concurrency control uses the classic two-condition algorithm
> +     * found in any textbook.
> +     */
> +
> +    /** Main lock guarding all access */
> +    private final ReentrantLock lock;
> +    /** Condition for waiting takes */
> +    private final Condition notEmpty;
> +    /** Condition for waiting puts */
> +    private final Condition notFull;
> +
> +    // Internal helper methods
> +
> +    /**
> +     * Circularly increment i.
> +     */
> +    final int inc(int i) {
> +        return (++i == items.length)? 0 : i;
> +    }
> +
> +    /**
> +     * Insert element at current put position, advance, and signal.
> +     * Call only when holding lock.
> +     */
> +    private void insert(E x) {
> +        items[putIndex] = x;
> +        putIndex = inc(putIndex);
> +        ++count;
> +        notEmpty.signal();
> +    }
> +
> +    /**
> +     * Extract element at current take position, advance, and signal.
> +     * Call only when holding lock.
> +     */
> +    private E extract() {
> +        final E[] items = this.items;
> +        E x = items[takeIndex];
> +        items[takeIndex] = null;
> +        takeIndex = inc(takeIndex);
> +        --count;
> +        notFull.signal();
> +        return x;
> +    }
> +
> +    /**
> +     * Utility for remove and iterator.remove: Delete item at position i.
> +     * Call only when holding lock.
> +     */
> +    void removeAt(int i) {
> +        final E[] items = this.items;
> +        // if removing front item, just advance
> +        if (i == takeIndex) {
> +            items[takeIndex] = null;
> +            takeIndex = inc(takeIndex);
> +        } else {
> +            // slide over all others up through putIndex.
> +            for (;;) {
> +                int nexti = inc(i);
> +                if (nexti != putIndex) {
> +                    items[i] = items[nexti];
> +                    i = nexti;
> +                } else {
> +                    items[i] = null;
> +                    putIndex = i;
> +                    break;
> +                }
> +            }
> +        }
> +        --count;
> +        notFull.signal();
> +    }
> +
> +    /**
> +     * Creates an <tt>ArrayBlockingQueue</tt> with the given (fixed)
> +     * capacity and default access policy.
> +     * @param capacity the capacity of this queue
> +     * @throws IllegalArgumentException if <tt>capacity</tt> is less than 1
> +     */
> +    public ArrayBlockingQueue(int capacity) {
> +        this(capacity, false);
> +    }
> +
> +    /**
> +     * Creates an <tt>ArrayBlockingQueue</tt> with the given (fixed)
> +     * capacity and the specified access policy.
> +     * @param capacity the capacity of this queue
> +     * @param fair if <tt>true</tt> then queue accesses for threads blocked
> +     * on insertion or removal, are processed in FIFO order; if <tt>false</tt>
> +     * the access order is unspecified.
> +     * @throws IllegalArgumentException if <tt>capacity</tt> is less than 1
> +     */
> +    public ArrayBlockingQueue(int capacity, boolean fair) {
> +        if (capacity <= 0)
> +            throw new IllegalArgumentException();
> +        this.items = (E[]) new Object[capacity];
> +        lock = new ReentrantLock(fair);
> +        notEmpty = lock.newCondition();
> +        notFull =  lock.newCondition();
> +    }
> +
> +    /**
> +     * Creates an <tt>ArrayBlockingQueue</tt> with the given (fixed)
> +     * capacity, the specified access policy and initially containing the
> +     * elements of the given collection,
> +     * added in traversal order of the collection's iterator.
> +     * @param capacity the capacity of this queue
> +     * @param fair if <tt>true</tt> then queue accesses for threads blocked
> +     * on insertion or removal, are processed in FIFO order; if <tt>false</tt>
> +     * the access order is unspecified.
> +     * @param c the collection of elements to initially contain
> +     * @throws IllegalArgumentException if <tt>capacity</tt> is less than
> +     * <tt>c.size()</tt>, or less than 1.
> +     * @throws NullPointerException if <tt>c</tt> or any element within it
> +     * is <tt>null</tt>
> +     */
> +    public ArrayBlockingQueue(int capacity, boolean fair,
> +                              Collection<? extends E> c) {
> +        this(capacity, fair);
> +        if (capacity < c.size())
> +            throw new IllegalArgumentException();
> +
> +        for (Iterator<? extends E> it = c.iterator(); it.hasNext();)
> +            add(it.next());
> +    }
> +
> +    /**
> +     * Inserts the specified element at the tail of this queue if possible,
> +     * returning immediately if this queue is full.
> +     *
> +     * @param o the element to add.
> +     * @return <tt>true</tt> if it was possible to add the element to
> +     *         this queue, else <tt>false</tt>
> +     * @throws NullPointerException if the specified element is <tt>null</tt>
> +     */
> +    public boolean offer(E o) {
> +        if (o == null) throw new NullPointerException();
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            if (count == items.length)
> +                return false;
> +            else {
> +                insert(o);
> +                return true;
> +            }
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    /**
> +     * Inserts the specified element at the tail of this queue, waiting if
> +     * necessary up to the specified wait time for space to become available.
> +     * @param o the element to add
> +     * @param timeout how long to wait before giving up, in units of
> +     * <tt>unit</tt>
> +     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
> +     * <tt>timeout</tt> parameter
> +     * @return <tt>true</tt> if successful, or <tt>false</tt> if
> +     * the specified waiting time elapses before space is available.
> +     * @throws InterruptedException if interrupted while waiting.
> +     * @throws NullPointerException if the specified element is <tt>null</tt>.
> +     */
> +    public boolean offer(E o, long timeout, TimeUnit unit)
> +        throws InterruptedException {
> +
> +        if (o == null) throw new NullPointerException();
> +        final ReentrantLock lock = this.lock;
> +        lock.lockInterruptibly();
> +        try {
> +            long nanos = unit.toNanos(timeout);
> +            for (;;) {
> +                if (count != items.length) {
> +                    insert(o);
> +                    return true;
> +                }
> +                if (nanos <= 0)
> +                    return false;
> +                try {
> +                    nanos = notFull.awaitNanos(nanos);
> +                } catch (InterruptedException ie) {
> +                    notFull.signal(); // propagate to non-interrupted thread
> +                    throw ie;
> +                }
> +            }
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +
> +    public E poll() {
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            if (count == 0)
> +                return null;
> +            E x = extract();
> +            return x;
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    public E poll(long timeout, TimeUnit unit) throws InterruptedException {
> +        final ReentrantLock lock = this.lock;
> +        lock.lockInterruptibly();
> +        try {
> +            long nanos = unit.toNanos(timeout);
> +            for (;;) {
> +                if (count != 0) {
> +                    E x = extract();
> +                    return x;
> +                }
> +                if (nanos <= 0)
> +                    return null;
> +                try {
> +                    nanos = notEmpty.awaitNanos(nanos);
> +                } catch (InterruptedException ie) {
> +                    notEmpty.signal(); // propagate to non-interrupted thread
> +                    throw ie;
> +                }
> +
> +            }
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +
> +    public boolean remove(Object o) {
> +        if (o == null) return false;
> +        final E[] items = this.items;
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            int i = takeIndex;
> +            int k = 0;
> +            for (;;) {
> +                if (k++ >= count)
> +                    return false;
> +                if (o.equals(items[i])) {
> +                    removeAt(i);
> +                    return true;
> +                }
> +                i = inc(i);
> +            }
> +
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    public E peek() {
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            return (count == 0) ? null : items[takeIndex];
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    public E take() throws InterruptedException {
> +        final ReentrantLock lock = this.lock;
> +        lock.lockInterruptibly();
> +        try {
> +            try {
> +                while (count == 0)
> +                    notEmpty.await();
> +            } catch (InterruptedException ie) {
> +                notEmpty.signal(); // propagate to non-interrupted thread
> +                throw ie;
> +            }
> +            E x = extract();
> +            return x;
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    /**
> +     * Adds the specified element to the tail of this queue, waiting if
> +     * necessary for space to become available.
> +     * @param o the element to add
> +     * @throws InterruptedException if interrupted while waiting.
> +     * @throws NullPointerException if the specified element is <tt>null</tt>.
> +     */
> +    public void put(E o) throws InterruptedException {
> +        if (o == null) throw new NullPointerException();
> +        final E[] items = this.items;
> +        final ReentrantLock lock = this.lock;
> +        lock.lockInterruptibly();
> +        try {
> +            try {
> +                while (count == items.length)
> +                    notFull.await();
> +            } catch (InterruptedException ie) {
> +                notFull.signal(); // propagate to non-interrupted thread
> +                throw ie;
> +            }
> +            insert(o);
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    // this doc comment is overridden to remove the reference to collections
> +    // greater in size than Integer.MAX_VALUE
> +    /**
> +     * Returns the number of elements in this queue.
> +     *
> +     * @return  the number of elements in this queue.
> +     */
> +    public int size() {
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            return count;
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    // this doc comment is a modified copy of the inherited doc comment,
> +    // without the reference to unlimited queues.
> +    /**
> +     * Returns the number of elements that this queue can ideally (in
> +     * the absence of memory or resource constraints) accept without
> +     * blocking. This is always equal to the initial capacity of this queue
> +     * less the current <tt>size</tt> of this queue.
> +     * <p>Note that you <em>cannot</em> always tell if
> +     * an attempt to <tt>add</tt> an element will succeed by
> +     * inspecting <tt>remainingCapacity</tt> because it may be the
> +     * case that a waiting consumer is ready to <tt>take</tt> an
> +     * element out of an otherwise full queue.
> +     */
> +    public int remainingCapacity() {
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            return items.length - count;
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +
> +    public boolean contains(Object o) {
> +        if (o == null) return false;
> +        final E[] items = this.items;
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            int i = takeIndex;
> +            int k = 0;
> +            while (k++ < count) {
> +                if (o.equals(items[i]))
> +                    return true;
> +                i = inc(i);
> +            }
> +            return false;
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    public Object[] toArray() {
> +        final E[] items = this.items;
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            Object[] a = new Object[count];
> +            int k = 0;
> +            int i = takeIndex;
> +            while (k < count) {
> +                a[k++] = items[i];
> +                i = inc(i);
> +            }
> +            return a;
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    public <T> T[] toArray(T[] a) {
> +        final E[] items = this.items;
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            if (a.length < count)
> +                a = (T[])java.lang.reflect.Array.newInstance(
> +                    a.getClass().getComponentType(),
> +                    count
> +                    );
> +
> +            int k = 0;
> +            int i = takeIndex;
> +            while (k < count) {
> +                a[k++] = (T)items[i];
> +                i = inc(i);
> +            }
> +            if (a.length > count)
> +                a[count] = null;
> +            return a;
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    public String toString() {
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            return super.toString();
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +
> +    public void clear() {
> +        final E[] items = this.items;
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            int i = takeIndex;
> +            int k = count;
> +            while (k-- > 0) {
> +                items[i] = null;
> +                i = inc(i);
> +            }
> +            count = 0;
> +            putIndex = 0;
> +            takeIndex = 0;
> +            notFull.signalAll();
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    public int drainTo(Collection<? super E> c) {
> +        if (c == null)
> +            throw new NullPointerException();
> +        if (c == this)
> +            throw new IllegalArgumentException();
> +        final E[] items = this.items;
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            int i = takeIndex;
> +            int n = 0;
> +            int max = count;
> +            while (n < max) {
> +                c.add(items[i]);
> +                items[i] = null;
> +                i = inc(i);
> +                ++n;
> +            }
> +            if (n > 0) {
> +                count = 0;
> +                putIndex = 0;
> +                takeIndex = 0;
> +                notFull.signalAll();
> +            }
> +            return n;
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +
> +    public int drainTo(Collection<? super E> c, int maxElements) {
> +        if (c == null)
> +            throw new NullPointerException();
> +        if (c == this)
> +            throw new IllegalArgumentException();
> +        if (maxElements <= 0)
> +            return 0;
> +        final E[] items = this.items;
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            int i = takeIndex;
> +            int n = 0;
> +            int sz = count;
> +            int max = (maxElements < count)? maxElements : count;
> +            while (n < max) {
> +                c.add(items[i]);
> +                items[i] = null;
> +                i = inc(i);
> +                ++n;
> +            }
> +            if (n > 0) {
> +                count -= n;
> +                takeIndex = i;
> +                notFull.signalAll();
> +            }
> +            return n;
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +
> +    /**
> +     * Returns an iterator over the elements in this queue in proper sequence.
> +     * The returned <tt>Iterator</tt> is a "weakly consistent" iterator that
> +     * will never throw {@link java.util.ConcurrentModificationException},
> +     * and guarantees to traverse elements as they existed upon
> +     * construction of the iterator, and may (but is not guaranteed to)
> +     * reflect any modifications subsequent to construction.
> +     *
> +     * @return an iterator over the elements in this queue in proper sequence.
> +     */
> +    public Iterator<E> iterator() {
> +        final ReentrantLock lock = this.lock;
> +        lock.lock();
> +        try {
> +            return new Itr();
> +        } finally {
> +            lock.unlock();
> +        }
> +    }
> +
> +    /**
> +     * Iterator for ArrayBlockingQueue
> +     */
> +    private class Itr implements Iterator<E> {
> +        /**
> +         * Index of element to be returned by next,
> +         * or a negative number if no such.
> +         */
> +        private int nextIndex;
> +
> +        /**
> +         * nextItem holds on to item fields because once we claim
> +         * that an element exists in hasNext(), we must return it in
> +         * the following next() call even if it was in the process of
> +         * being removed when hasNext() was called.
> +         **/
> +        private E nextItem;
> +
> +        /**
> +         * Index of element returned by most recent call to next.
> +         * Reset to -1 if this element is deleted by a call to remove.
> +         */
> +        private int lastRet;
> +
> +        Itr() {
> +            lastRet = -1;
> +            if (count == 0)
> +                nextIndex = -1;
> +            else {
> +                nextIndex = takeIndex;
> +                nextItem = items[takeIndex];
> +            }
> +        }
> +
> +        public boolean hasNext() {
> +            /*
> +             * No sync. We can return true by mistake here
> +             * only if this iterator passed across threads,
> +             * which we don't support anyway.
> +             */
> +            return nextIndex >= 0;
> +        }
> +
> +        /**
> +         * Check whether nextIndex is valid; if so setting nextItem.
> +         * Stops iterator when either hits putIndex or sees null item.
> +         */
> +        private void checkNext() {
> +            if (nextIndex == putIndex) {
> +                nextIndex = -1;
> +                nextItem = null;
> +            } else {
> +                nextItem = items[nextIndex];
> +                if (nextItem == null)
> +                    nextIndex = -1;
> +            }
> +        }
> +
> +        public E next() {
> +            final ReentrantLock lock = ArrayBlockingQueue.this.lock;
> +            lock.lock();
> +            try {
> +                if (nextIndex < 0)
> +                    throw new NoSuchElementException();
> +                lastRet = nextIndex;
> +                E x = nextItem;
> +                nextIndex = inc(nextIndex);
> +                checkNext();
> +                return x;
> +            } finally {
> +                lock.unlock();
> +            }
> +        }
> +
> +        public void remove() {
> +            final ReentrantLock lock = ArrayBlockingQueue.this.lock;
> +            lock.lock();
> +            try {
> +                int i = lastRet;
> +                if (i == -1)
> +                    throw new IllegalStateException();
> +                lastRet = -1;
> +
> +                int ti = takeIndex;
> +                removeAt(i);
> +                // back up cursor (reset to front if was first element)
> +                nextIndex = (i == ti) ? takeIndex : i;
> +                checkNext();
> +            } finally {
> +                lock.unlock();
> +            }
> +        }
> +    }
> +}
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
> ------------------------------------------------------------------------------
>     svn:eol-style = native
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,227 @@
> +/*
> + * Written by Doug Lea with assistance from members of JCP JSR-166
> + * Expert Group and released to the public domain, as explained at
> + * http://creativecommons.org/licenses/publicdomain
> + */
> +
> +package java.util.concurrent;
> +
> +import java.util.Collection;
> +import java.util.Queue;
> +
> +/**
> + * A {@link java.util.Queue} that additionally supports operations
> + * that wait for the queue to become non-empty when retrieving an element,
> + * and wait for space to become available in the queue when storing an 
> + * element.
> + *
> + * <p>A <tt>BlockingQueue</tt> does not accept <tt>null</tt> elements.
> + * Implementations throw <tt>NullPointerException</tt> on attempts
> + * to <tt>add</tt>, <tt>put</tt> or <tt>offer</tt> a <tt>null</tt>.  A
> + * <tt>null</tt> is used as a sentinel value to indicate failure of
> + * <tt>poll</tt> operations.
> + *
> + * <p>A <tt>BlockingQueue</tt> may be capacity bounded. At any given
> + * time it may have a <tt>remainingCapacity</tt> beyond which no
> + * additional elements can be <tt>put</tt> without blocking.
> + * A <tt>BlockingQueue</tt> without any intrinsic capacity constraints always
> + * reports a remaining capacity of <tt>Integer.MAX_VALUE</tt>.
> + *
> + * <p> While <tt>BlockingQueue</tt> is designed to be used primarily
> + * for producer-consumer queues, it additionally supports the {@link
> + * java.util.Collection} interface.  So, for example, it is possible
> + * to remove an arbitrary element from a queue using
> + * <tt>remove(x)</tt>. However, such operations are in general
> + * <em>not</em> performed very efficiently, and are intended for only
> + * occasional use, such as when a queued message is cancelled.  Also,
> + * the bulk Collection operations, most notably <tt>addAll</tt>, are
> + * <em>not</em> necessarily performed atomically, so it is possible
> + * for <tt>addAll(c)</tt> to fail (throwing an exception) after adding
> + * only some of the elements in <tt>c</tt>.
> + *
> + * <p>A <tt>BlockingQueue</tt> does <em>not</em> intrinsically support
> + * any kind of &quot;close&quot; or &quot;shutdown&quot; operation to
> + * indicate that no more items will be added.  The needs and usage of
> + * such features tend to be implementation-dependent. For example, a
> + * common tactic is for producers to insert special
> + * <em>end-of-stream</em> or <em>poison</em> objects, that are
> + * interpreted accordingly when taken by consumers.
> + *
> + * <p>
> + * Usage example, based on a typical producer-consumer scenario.
> + * Note that a <tt>BlockingQueue</tt> can safely be used with multiple
> + * producers and multiple consumers.
> + * <pre>
> + * class Producer implements Runnable {
> + *   private final BlockingQueue queue;
> + *   Producer(BlockingQueue q) { queue = q; }
> + *   public void run() {
> + *     try {
> + *       while(true) { queue.put(produce()); }
> + *     } catch (InterruptedException ex) { ... handle ...}
> + *   }
> + *   Object produce() { ... }
> + * }
> + *
> + * class Consumer implements Runnable {
> + *   private final BlockingQueue queue;
> + *   Consumer(BlockingQueue q) { queue = q; }
> + *   public void run() {
> + *     try {
> + *       while(true) { consume(queue.take()); }
> + *     } catch (InterruptedException ex) { ... handle ...}
> + *   }
> + *   void consume(Object x) { ... }
> + * }
> + *
> + * class Setup {
> + *   void main() {
> + *     BlockingQueue q = new SomeQueueImplementation();
> + *     Producer p = new Producer(q);
> + *     Consumer c1 = new Consumer(q);
> + *     Consumer c2 = new Consumer(q);
> + *     new Thread(p).start();
> + *     new Thread(c1).start();
> + *     new Thread(c2).start();
> + *   }
> + * }
> + * </pre>
> + *
> + * <p>This interface is a member of the
> + * <a href="{@docRoot}/../guide/collections/index.html">
> + * Java Collections Framework</a>.
> + *  
> + * @since 1.5
> + * @author Doug Lea
> + * @param <E> the type of elements held in this collection
> + */
> +public interface BlockingQueue<E> extends Queue<E> {
> +
> +    /**
> +     * Inserts the specified element into this queue, if possible.  When
> +     * using queues that may impose insertion restrictions (for
> +     * example capacity bounds), method <tt>offer</tt> is generally
> +     * preferable to method {@link Collection#add}, which can fail to
> +     * insert an element only by throwing an exception.
> +     *
> +     * @param o the element to add.
> +     * @return <tt>true</tt> if it was possible to add the element to
> +     *         this queue, else <tt>false</tt>
> +     * @throws NullPointerException if the specified element is <tt>null</tt>
> +     */
> +    boolean offer(E o);
> +    
> +    /**
> +     * Inserts the specified element into this queue, waiting if necessary
> +     * up to the specified wait time for space to become available.
> +     * @param o the element to add
> +     * @param timeout how long to wait before giving up, in units of
> +     * <tt>unit</tt>
> +     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
> +     * <tt>timeout</tt> parameter
> +     * @return <tt>true</tt> if successful, or <tt>false</tt> if
> +     * the specified waiting time elapses before space is available.
> +     * @throws InterruptedException if interrupted while waiting.
> +     * @throws NullPointerException if the specified element is <tt>null</tt>.
> +     */
> +    boolean offer(E o, long timeout, TimeUnit unit)
> +        throws InterruptedException;
> +
> +    /**
> +     * Retrieves and removes the head of this queue, waiting
> +     * if necessary up to the specified wait time if no elements are
> +     * present on this queue.
> +     * @param timeout how long to wait before giving up, in units of
> +     * <tt>unit</tt>
> +     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
> +     * <tt>timeout</tt> parameter
> +     * @return the head of this queue, or <tt>null</tt> if the
> +     * specified waiting time elapses before an element is present.
> +     * @throws InterruptedException if interrupted while waiting.
> +     */
> +    E poll(long timeout, TimeUnit unit)
> +        throws InterruptedException;
> +
> +    /**
> +     * Retrieves and removes the head of this queue, waiting
> +     * if no elements are present on this queue.
> +     * @return the head of this queue
> +     * @throws InterruptedException if interrupted while waiting.
> +     */
> +    E take() throws InterruptedException;
> +
> +    /**
> +     * Adds the specified element to this queue, waiting if necessary for
> +     * space to become available.
> +     * @param o the element to add
> +     * @throws InterruptedException if interrupted while waiting.
> +     * @throws NullPointerException if the specified element is <tt>null</tt>.
> +     */
> +    void put(E o) throws InterruptedException;
> +
> +    /**
> +     * Returns the number of elements that this queue can ideally (in
> +     * the absence of memory or resource constraints) accept without
> +     * blocking, or <tt>Integer.MAX_VALUE</tt> if there is no
> +     * intrinsic limit.
> +     * <p>Note that you <em>cannot</em> always tell if
> +     * an attempt to <tt>add</tt> an element will succeed by
> +     * inspecting <tt>remainingCapacity</tt> because it may be the
> +     * case that a waiting consumer is ready to <tt>take</tt> an
> +     * element out of an otherwise full queue.
> +     * @return the remaining capacity
> +     */
> +    int remainingCapacity();
> +
> +    /**
> +     * Adds the specified element to this queue if it is possible to
> +     * do so immediately, returning <tt>true</tt> upon success, else
> +     * throwing an IllegalStateException.  
> +     * @param o the element
> +     * @return <tt>true</tt> (as per the general contract of
> +     *         <tt>Collection.add</tt>).
> +     *
> +     * @throws NullPointerException if the specified element is <tt>null</tt>
> +     * @throws IllegalStateException if element cannot be added
> +     */
> +    boolean add(E o);
> +
> +    /**
> +     * Removes all available elements from this queue and adds them
> +     * into the given collection.  This operation may be more
> +     * efficient than repeatedly polling this queue.  A failure
> +     * encountered while attempting to <tt>add</tt> elements to
> +     * collection <tt>c</tt> may result in elements being in neither,
> +     * either or both collections when the associated exception is
> +     * thrown. Attempts to drain a queue to itself result in
> +     * <tt>IllegalArgumentException</tt>. Further, the behavior of
> +     * this operation is undefined if the specified collection is
> +     * modified while the operation is in progress.
> +     *
> +     * @param c the collection to transfer elements into
> +     * @return the number of elements transferred.
> +     * @throws NullPointerException if c is null
> +     * @throws IllegalArgumentException if c is this queue
> +     * 
> +     */
> +    int drainTo(Collection<? super E> c);
> +    
> +    /**
> +     * Removes at most the given number of available elements from
> +     * this queue and adds them into the given collection.  A failure
> +     * encountered while attempting to <tt>add</tt> elements to
> +     * collection <tt>c</tt> may result in elements being in neither,
> +     * either or both collections when the associated exception is
> +     * thrown. Attempts to drain a queue to itself result in
> +     * <tt>IllegalArgumentException</tt>. Further, the behavior of
> +     * this operation is undefined if the specified collection is
> +     * modified while the operation is in progress.
> +     *
> +     * @param c the collection to transfer elements into
> +     * @param maxElements the maximum number of elements to transfer
> +     * @return the number of elements transferred.
> +     * @throws NullPointerException if c is null
> +     * @throws IllegalArgumentException if c is this queue
> +     */
> +    int drainTo(Collection<? super E> c, int maxElements);
> +}
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java
> ------------------------------------------------------------------------------
>     svn:eol-style = native
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,38 @@
> +/*
> + * Written by Doug Lea with assistance from members of JCP JSR-166
> + * Expert Group and released to the public domain, as explained at
> + * http://creativecommons.org/licenses/publicdomain
> + */
> +
> +package java.util.concurrent;
> +
> +/**
> + * Exception thrown when a thread tries to wait upon a barrier that is
> + * in a broken state, or which enters the broken state while the thread
> + * is waiting.
> + *
> + * @see CyclicBarrier
> + *
> + * @since 1.5
> + * @author Doug Lea
> + *
> + */
> +public class BrokenBarrierException extends Exception {
> +    private static final long serialVersionUID = 7117394618823254244L;
> +
> +    /**
> +     * Constructs a <tt>BrokenBarrierException</tt> with no specified detail
> +     * message.
> +     */
> +    public BrokenBarrierException() {}
> +
> +    /**
> +     * Constructs a <tt>BrokenBarrierException</tt> with the specified
> +     * detail message.
> +     *
> +     * @param message the detail message
> +     */
> +    public BrokenBarrierException(String message) {
> +        super(message);
> +    }
> +}
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java
> ------------------------------------------------------------------------------
>     svn:eol-style = native
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,36 @@
> +/*
> + * Written by Doug Lea with assistance from members of JCP JSR-166
> + * Expert Group and released to the public domain, as explained at
> + * http://creativecommons.org/licenses/publicdomain
> + */
> +
> +package java.util.concurrent;
> +
> +/**
> + * A task that returns a result and may throw an exception.
> + * Implementors define a single method with no arguments called
> + * <tt>call</tt>.
> + *
> + * <p>The <tt>Callable</tt> interface is similar to {@link
> + * java.lang.Runnable}, in that both are designed for classes whose
> + * instances are potentially executed by another thread.  A
> + * <tt>Runnable</tt>, however, does not return a result and cannot
> + * throw a checked exception.
> + *
> + * <p> The {@link Executors} class contains utility methods to
> + * convert from other common forms to <tt>Callable</tt> classes.
> + *
> + * @see Executor
> + * @since 1.5
> + * @author Doug Lea
> + * @param <V> the result type of method <tt>call</tt>
> + */
> +public interface Callable<V> {
> +    /**
> +     * Computes a result, or throws an exception if unable to do so.
> +     *
> +     * @return computed result
> +     * @throws Exception if unable to compute a result
> +     */
> +    V call() throws Exception;
> +}
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/Callable.java
> ------------------------------------------------------------------------------
>     svn:eol-style = native
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,34 @@
> +/*
> + * Written by Doug Lea with assistance from members of JCP JSR-166
> + * Expert Group and released to the public domain, as explained at
> + * http://creativecommons.org/licenses/publicdomain
> + */
> +
> +package java.util.concurrent;
> +
> +/**
> + * Exception indicating that the result of a value-producing task,
> + * such as a {@link FutureTask}, cannot be retrieved because the task
> + * was cancelled.
> + *
> + * @since 1.5
> + * @author Doug Lea
> + */
> +public class CancellationException extends IllegalStateException {
> +    private static final long serialVersionUID = -9202173006928992231L;
> +
> +    /**
> +     * Constructs a <tt>CancellationException</tt> with no detail message.
> +     */
> +    public CancellationException() {}
> +
> +    /**
> +     * Constructs a <tt>CancellationException</tt> with the specified detail
> +     * message.
> +     *
> +     * @param message the detail message
> +     */
> +    public CancellationException(String message) {
> +        super(message);
> +    }
> +}
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CancellationException.java
> ------------------------------------------------------------------------------
>     svn:eol-style = native
> 
> Added: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java
> URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java?rev=421111&view=auto
> ==============================================================================
> --- incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java (added)
> +++ incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java Tue Jul 11 21:12:04 2006
> @@ -0,0 +1,92 @@
> +/*
> + * Written by Doug Lea with assistance from members of JCP JSR-166
> + * Expert Group and released to the public domain, as explained at
> + * http://creativecommons.org/licenses/publicdomain
> + */
> +
> +package java.util.concurrent;
> +
> +/**
> + * A service that decouples the production of new asynchronous tasks
> + * from the consumption of the results of completed tasks.  Producers
> + * <tt>submit</tt> tasks for execution. Consumers <tt>take</tt>
> + * completed tasks and process their results in the order they
> + * complete.  A <tt>CompletionService</tt> can for example be used to
> + * manage asynchronous IO, in which tasks that perform reads are
> + * submitted in one part of a program or system, and then acted upon
> + * in a different part of the program when the reads complete,
> + * possibly in a different order than they were requested.
> +
> + * <p>
> + *
> + * Typically, a <tt>CompletionService</tt> relies on a separate {@link
> + * Executor} to actually execute the tasks, in which case the
> + * <tt>CompletionService</tt> only manages an internal completion
> + * queue. The {@link ExecutorCompletionService} class provides an
> + * implementation of this approach.
> + *
> + */
> +public interface CompletionService<V> {
> +    /**
> +     * Submits a value-returning task for execution and returns a Future
> +     * representing the pending results of the task. Upon completion,
> +     * this task may be taken or polled.
> +     *
> +     * @param task the task to submit
> +     * @return a Future representing pending completion of the task
> +     * @throws RejectedExecutionException if task cannot be scheduled
> +     * for execution
> +     * @throws NullPointerException if task null     
> +     */
> +    Future<V> submit(Callable<V> task);
> +
> +
> +    /**
> +     * Submits a Runnable task for execution and returns a Future 
> +     * representing that task. Upon completion,
> +     * this task may be taken or polled.
> +     *
> +     * @param task the task to submit
> +     * @param result the result to return upon successful completion
> +     * @return a Future representing pending completion of the task,
> +     * and whose <tt>get()</tt> method will return the given result value 
> +     * upon completion
> +     * @throws RejectedExecutionException if task cannot be scheduled
> +     * for execution
> +     * @throws NullPointerException if task null     
> +     */
> +    Future<V> submit(Runnable task, V result);
> +
> +    /**
> +     * Retrieves and removes the Future representing the next
> +     * completed task, waiting if none are yet present.
> +     * @return the Future representing the next completed task
> +     * @throws InterruptedException if interrupted while waiting.
> +     */
> +    Future<V> take() throws InterruptedException;
> +
> +
> +    /**
> +     * Retrieves and removes the Future representing the next
> +     * completed task or <tt>null</tt> if none are present.
> +     *
> +     * @return the Future representing the next completed task, or
> +     * <tt>null</tt> if none are present.
> +     */
> +    Future<V> poll();
> +
> +    /**
> +     * Retrieves and removes the Future representing the next
> +     * completed task, waiting if necessary up to the specified wait
> +     * time if none are yet present.
> +     * @param timeout how long to wait before giving up, in units of
> +     * <tt>unit</tt>
> +     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
> +     * <tt>timeout</tt> parameter
> +     * @return the Future representing the next completed task or
> +     * <tt>null</tt> if the specified waiting time elapses before one
> +     * is present.
> +     * @throws InterruptedException if interrupted while waiting.
> +     */
> +    Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException;
> +}
> 
> Propchange: incubator/harmony/enhanced/classlib/trunk/sandbox/juc-proposal/concurrent/src/main/java/java/util/concurrent/CompletionService.java
> ------------------------------------------------------------------------------
>     svn:eol-style = native
> 
> 
> 

-- 

Tim Ellison (t.p.ellison@gmail.com)
IBM Java technology centre, UK.

---------------------------------------------------------------------
Terms of use : http://incubator.apache.org/harmony/mailing.html
To unsubscribe, e-mail: harmony-dev-unsubscribe@incubator.apache.org
For additional commands, e-mail: harmony-dev-help@incubator.apache.org


Mime
View raw message