You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by nd...@apache.org on 2006/08/24 05:42:33 UTC
svn commit: r434296 [1/19] - in /incubator/harmony/enhanced/classlib/trunk:
make/ modules/concurrent/ modules/concurrent/.settings/
modules/concurrent/META-INF/ modules/concurrent/make/
modules/concurrent/src/ modules/concurrent/src/main/ modules/concu...
Author: ndbeyer
Date: Wed Aug 23 20:42:25 2006
New Revision: 434296
URL: http://svn.apache.org/viewvc?rev=434296&view=rev
Log:
Initial commit of the concurrent module (tests are currently disabled).
Added:
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/ (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.project (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.core.prefs
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.ui.prefs
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.pde.core.prefs
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/META-INF/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/META-INF/MANIFEST.MF
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ConcurrentHashMap.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ConcurrentMap.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CopyOnWriteArrayList.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CopyOnWriteArraySet.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CountDownLatch.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CyclicBarrier.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/DelayQueue.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Delayed.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Exchanger.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ExecutionException.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Executor.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ExecutorCompletionService.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ExecutorService.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Executors.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Future.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/FutureTask.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/LinkedBlockingQueue.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/PriorityBlockingQueue.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/RejectedExecutionException.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/RejectedExecutionHandler.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ScheduledExecutorService.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ScheduledFuture.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ScheduledThreadPoolExecutor.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Semaphore.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/SynchronousQueue.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ThreadFactory.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ThreadPoolExecutor.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/TimeUnit.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/TimeoutException.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicBoolean.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicInteger.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicIntegerArray.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLong.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLongArray.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLongFieldUpdater.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicMarkableReference.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReference.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReferenceArray.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicStampedReference.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/package.html (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/Condition.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/Lock.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/LockSupport.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/ReadWriteLock.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/ReentrantLock.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/package.html (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/package.html (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/resources/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AbstractExecutorServiceTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AbstractQueueTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AbstractQueuedSynchronizerTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ArrayBlockingQueueTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicBooleanTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicIntegerArrayTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicIntegerFieldUpdaterTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicIntegerTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicLongArrayTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicLongFieldUpdaterTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicLongTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicMarkableReferenceTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicReferenceArrayTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicReferenceFieldUpdaterTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicReferenceTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/AtomicStampedReferenceTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ConcurrentHashMapTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ConcurrentLinkedQueueTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/CopyOnWriteArrayListTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/CopyOnWriteArraySetTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/CountDownLatchTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/CyclicBarrierTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/JSR166TestCase.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedBlockingQueueTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LinkedListTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/LockSupportTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityBlockingQueueTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/PriorityQueueTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ReentrantLockTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ReentrantReadWriteLockTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ScheduledExecutorTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/SemaphoreTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/SynchronousQueueTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/SystemTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ThreadLocalTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ThreadPoolExecutorTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/ThreadTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/java/TimeUnitTest.java (with props)
incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/test/resources/
incubator/harmony/enhanced/classlib/trunk/modules/luni-kernel/src/main/java/sun/
incubator/harmony/enhanced/classlib/trunk/modules/luni-kernel/src/main/java/sun/misc/
incubator/harmony/enhanced/classlib/trunk/modules/luni-kernel/src/main/java/sun/misc/Unsafe.java (with props)
Modified:
incubator/harmony/enhanced/classlib/trunk/make/build-java.xml
incubator/harmony/enhanced/classlib/trunk/modules/luni-kernel/META-INF/MANIFEST.MF
incubator/harmony/enhanced/classlib/trunk/modules/luni-kernel/make/patternset.txt
Modified: incubator/harmony/enhanced/classlib/trunk/make/build-java.xml
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/make/build-java.xml?rev=434296&r1=434295&r2=434296&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/make/build-java.xml (original)
+++ incubator/harmony/enhanced/classlib/trunk/make/build-java.xml Wed Aug 23 20:42:25 2006
@@ -106,10 +106,12 @@
<src path="modules/awt/src/main/java/${hy.os}" />
<src path="modules/awt/src/main/java/common" />
<src path="modules/beans/src/main/java" />
+ <src path="modules/concurrent/src/main/java/" />
<src path="modules/crypto/src/main/java" />
<src path="modules/instrument/src/main/java" />
<src path="modules/jndi/src/main/java" />
<src path="modules/logging/src/main/java" />
+ <src path="modules/lang-management/src/main/java/" />
<src path="modules/luni-kernel/src/main/java" />
<src path="modules/luni/src/main/java" />
<src path="modules/math/src/main/java" />
@@ -128,8 +130,6 @@
<src path="modules/swing/src/main/java/common" />
<src path="modules/text/src/main/java" />
<src path="modules/x-net/src/main/java/" />
- <src path="modules/lang-management/src/main/java/" />
-
<classpath location="${build.output}" />
<classpath>
<fileset dir="${depends.jars}">
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/
------------------------------------------------------------------------------
--- svn:ignore (added)
+++ svn:ignore Wed Aug 23 20:42:25 2006
@@ -0,0 +1 @@
+bin
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath Wed Aug 23 20:42:25 2006
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry output="bin/main" kind="src" path="src/main/java"/>
+ <classpathentry output="bin/main" kind="src" path="src/main/resources"/>
+ <classpathentry output="bin/test" kind="src" path="src/test/java"/>
+ <classpathentry output="bin/test" 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="bin/main"/>
+</classpath>
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.classpath
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.project
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.project?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.project (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.project Wed Aug 23 20:42:25 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/modules/concurrent/.project
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.core.prefs
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.core.prefs?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.core.prefs (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.core.prefs Wed Aug 23 20:42:25 2006
@@ -0,0 +1,12 @@
+#Wed Aug 23 22:35:26 CDT 2006
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+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/modules/concurrent/.settings/org.eclipse.jdt.ui.prefs
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.ui.prefs?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.ui.prefs (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.jdt.ui.prefs Wed Aug 23 20:42:25 2006
@@ -0,0 +1,3 @@
+#Wed Aug 23 22:35:26 CDT 2006
+eclipse.preferences.version=1
+internal.default.compliance=default
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.pde.core.prefs
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.pde.core.prefs?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.pde.core.prefs (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/.settings/org.eclipse.pde.core.prefs Wed Aug 23 20:42:25 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/modules/concurrent/META-INF/MANIFEST.MF
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/META-INF/MANIFEST.MF?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/META-INF/MANIFEST.MF (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/META-INF/MANIFEST.MF Wed Aug 23 20:42:25 2006
@@ -0,0 +1,19 @@
+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.math,
+ java.net,
+ java.security,
+ java.util,
+ sun.misc
+Export-Package: java.util.concurrent,
+ java.util.concurrent.atomic,
+ java.util.concurrent.locks
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt Wed Aug 23 20:42:25 2006
@@ -0,0 +1,4 @@
+The majority of this code base is sourced from the Concurrency Interest site and the
+associated ViewCVS server.
+
+URL: http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/?only_with_tag=JSR166_PFD
\ No newline at end of file
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/README.txt
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml Wed Aug 23 20:42:25 2006
@@ -0,0 +1,150 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2006 The Apache Software Foundation or its
+ licensors, as applicable.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<project name="CONCURRENT Build" default="build" basedir=".">
+ <description>Build for CONCURRENT component</description>
+
+ <!-- import common properties -->
+ <import file="${basedir}/../../make/properties.xml" />
+
+ <!-- set global properties for this build. -->
+ <xmlproperty file="make/hyproperties.xml" semanticAttributes="true" />
+
+ <fileset id="classes" dir="${hy.build}">
+ <includesfile name="${hy.concurrent}/make/patternset.txt" />
+ <excludesfile name="${hy.hdk}/build/patternsets/luni-kernel.txt" />
+ <excludesfile name="${hy.hdk}/build/patternsets/security-kernel.txt" />
+ </fileset>
+
+ <!-- Set build.compiler to "org.eclipse.jdt.core.JDTCompilerAdapter" to
+ use the Eclipse Java compiler. -->
+ <property name="build.compiler" value="modern" />
+
+ <target name="build" depends="compile.java, build.jar" />
+
+ <target name="test" ><!-- depends="build, compile.tests, run.tests" --></target>
+
+ <target name="clean">
+ <delete failonerror="false">
+ <fileset refid="classes" />
+ <fileset dir="${hy.concurrent.bin.test}" />
+ </delete>
+ </target>
+
+ <target name="compile.java">
+ <echo message="Compiling CONCURRENT classes" />
+
+ <mkdir dir="${hy.build}" />
+
+ <javac sourcepath=""
+ srcdir="${hy.concurrent.src.main.java}"
+ destdir="${hy.build}"
+ source="${hy.javac.source}"
+ target="${hy.javac.target}"
+ debug="${hy.javac.debug}">
+
+ <bootclasspath>
+ <fileset dir="${hy.jdk}/jre/lib/boot">
+ <include name="**/*.jar" />
+ </fileset>
+ </bootclasspath>
+ </javac>
+ </target>
+
+ <target name="build.jar" depends="svn-info">
+ <jar destfile="${hy.jdk}/jre/lib/boot/${hy.concurrent.packaging.jarname}.jar"
+ manifest="${hy.concurrent}/META-INF/MANIFEST.MF">
+ <fileset refid="classes" />
+ <manifest>
+ <attribute name="Implementation-Version" value="${svn.info}"/>
+ </manifest>
+ </jar>
+ </target>
+
+ <target name="compile.tests">
+ <echo message="Compiling CONCURRENT tests" />
+
+ <mkdir dir="${hy.concurrent.bin.test}" />
+
+ <javac srcdir="${hy.concurrent.src.test.java}"
+ destdir="${hy.concurrent.bin.test}"
+ sourcepath=""
+ source="${hy.javac.source}"
+ target="${hy.javac.target}"
+ debug="${hy.javac.debug}">
+
+ <bootclasspath>
+ <fileset dir="${hy.jdk}/jre/lib/boot">
+ <include name="**/*.jar" />
+ </fileset>
+ </bootclasspath>
+ <classpath location="../../build/tests" />
+ <classpath location="${hy.hdk}/build/test/support.jar" />
+ </javac>
+ </target>
+
+ <target name="run.tests">
+
+ <mkdir dir="${hy.tests.reports}" />
+
+ <property name="test.jre.home" value="${hy.jdk}/jre" />
+
+ <junit fork="yes"
+ forkmode="once"
+ printsummary="withOutAndErr"
+ errorproperty="test.errors"
+ failureproperty="test.failures"
+ showoutput="on"
+ dir="${basedir}"
+ jvm="${test.jre.home}/bin/java">
+
+ <jvmarg value="-showversion"/>
+
+ <env key="JAVA_HOME" value="${test.jre.home}"/>
+
+ <classpath>
+ <pathelement path="${hy.concurrent.bin.test}"/>
+ </classpath>
+ <classpath location="${hy.hdk}/build/test/support.jar" />
+
+ <formatter type="xml" />
+
+ <test name="${test.case}" todir="${hy.tests.reports}"
+ if="test.case" />
+
+ <batchtest todir="${hy.tests.reports}" haltonfailure="no"
+ unless="test.case">
+
+ <fileset dir="${hy.concurrent.src.test.java}"/>
+ </batchtest>
+ </junit>
+ <antcall target="touch-failures-file" />
+ <antcall target="touch-errors-file" />
+ </target>
+
+ <target name="touch-failures-file" if="test.failures">
+ <echo file="${hy.tests.reports}/test.failures"
+ append="true">concurrent${line.separator}</echo>
+ </target>
+
+ <target name="touch-errors-file" if="test.errors">
+ <echo file="${hy.tests.reports}/test.errors"
+ append="true">concurrent${line.separator}</echo>
+ </target>
+
+</project>
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/build.xml
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml Wed Aug 23 20:42:25 2006
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright 2006 The Apache Software Foundation or its licensors, as applicable.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<hy>
+ <concurrent location=".">
+ <src>
+ <main>
+ <java location="src/main/java" />
+ <resources location="src/main/resources" />
+ </main>
+ <test>
+ <java location="src/test/java" />
+ <resources location="src/test/resources" />
+ </test>
+ </src>
+ <bin>
+ <main location="bin/main" />
+ <test location="bin/test" />
+ </bin>
+ <packaging>
+ <jarname>concurrent</jarname>
+ </packaging>
+ </concurrent>
+
+ <hdk location="../../deploy" />
+ <jdk location="../../deploy/jdk" />
+ <build location="../../build/classes" />
+
+ <tests>
+ <reports location="../../build/test_report" />
+ </tests>
+</hy>
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/hyproperties.xml
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt Wed Aug 23 20:42:25 2006
@@ -0,0 +1,17 @@
+# Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+java/util/concurrent/*
+java/util/concurrent/atomic/*
+java/util/concurrent/locks/*
Propchange: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/make/patternset.txt
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java Wed Aug 23 20:42:25 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/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java Wed Aug 23 20:42:25 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 "bounded buffer", 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/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java Wed Aug 23 20:42:25 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 "close" or "shutdown" 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/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java Wed Aug 23 20:42:25 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/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java Wed Aug 23 20:42:25 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/modules/concurrent/src/main/java/java/util/concurrent/Callable.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java Wed Aug 23 20:42:25 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/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java?rev=434296&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java Wed Aug 23 20:42:25 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/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java
------------------------------------------------------------------------------
svn:eol-style = native