Return-Path: Delivered-To: apmail-incubator-harmony-commits-archive@www.apache.org Received: (qmail 42115 invoked from network); 24 Aug 2006 03:43:26 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 24 Aug 2006 03:43:26 -0000 Received: (qmail 32515 invoked by uid 500); 24 Aug 2006 03:43:24 -0000 Delivered-To: apmail-incubator-harmony-commits-archive@incubator.apache.org Received: (qmail 32424 invoked by uid 500); 24 Aug 2006 03:43:24 -0000 Mailing-List: contact harmony-commits-help@incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: harmony-dev@incubator.apache.org Delivered-To: mailing list harmony-commits@incubator.apache.org Received: (qmail 32254 invoked by uid 99); 24 Aug 2006 03:43:23 -0000 Received: from asf.osuosl.org (HELO asf.osuosl.org) (140.211.166.49) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 23 Aug 2006 20:43:23 -0700 X-ASF-Spam-Status: No, hits=-8.6 required=10.0 tests=ALL_TRUSTED,INFO_TLD,NO_REAL_NAME X-Spam-Check-By: apache.org Received-SPF: pass (asf.osuosl.org: local policy) Received: from [140.211.166.113] (HELO eris.apache.org) (140.211.166.113) by apache.org (qpsmtpd/0.29) with ESMTP; Wed, 23 Aug 2006 20:43:13 -0700 Received: by eris.apache.org (Postfix, from userid 65534) id B08301A981A; Wed, 23 Aug 2006 20:42:53 -0700 (PDT) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: 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... Date: Thu, 24 Aug 2006 03:42:33 -0000 To: harmony-commits@incubator.apache.org From: ndbeyer@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20060824034253.B08301A981A@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N 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 @@ + + @@ -128,8 +130,6 @@ - - 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 @@ + + + + + + + + + + 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 @@ + + + concurrent + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + + org.eclipse.pde.PluginNature + org.eclipse.jdt.core.javanature + + 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 @@ + + + + + Build for CONCURRENT component + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + concurrent${line.separator} + + + + concurrent${line.separator} + + + 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 @@ + + + + + + +
+ + +
+ + + + + + +
+ + + + concurrent + + + + + + + + + + + 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 submit, + * invokeAny and invokeAll methods using the default + * {@link FutureTask} class provided in this package. For example, + * the implementation of submit(Runnable) creates an + * associated FutureTask 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 ftask = new FutureTask(task, null); + execute(ftask); + return ftask; + } + + public Future submit(Runnable task, T result) { + if (task == null) throw new NullPointerException(); + FutureTask ftask = new FutureTask(task, result); + execute(ftask); + return ftask; + } + + public Future submit(Callable task) { + if (task == null) throw new NullPointerException(); + FutureTask ftask = new FutureTask(task); + execute(ftask); + return ftask; + } + + /** + * the main mechanics of invokeAny. + */ + private T doInvokeAny(Collection> 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> futures= new ArrayList>(ntasks); + ExecutorCompletionService ecs = + new ExecutorCompletionService(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> it = tasks.iterator(); + + // Start one task for sure; the rest incrementally + futures.add(ecs.submit(it.next())); + --ntasks; + int active = 1; + + for (;;) { + Future 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 f : futures) + f.cancel(true); + } + } + + public T invokeAny(Collection> tasks) + throws InterruptedException, ExecutionException { + try { + return doInvokeAny(tasks, false, 0); + } catch (TimeoutException cannotHappen) { + assert false; + return null; + } + } + + public T invokeAny(Collection> tasks, + long timeout, TimeUnit unit) + throws InterruptedException, ExecutionException, TimeoutException { + return doInvokeAny(tasks, true, unit.toNanos(timeout)); + } + + public List> invokeAll(Collection> tasks) + throws InterruptedException { + if (tasks == null) + throw new NullPointerException(); + List> futures = new ArrayList>(tasks.size()); + boolean done = false; + try { + for (Callable t : tasks) { + FutureTask f = new FutureTask(t); + futures.add(f); + execute(f); + } + for (Future f : futures) { + if (!f.isDone()) { + try { + f.get(); + } catch(CancellationException ignore) { + } catch(ExecutionException ignore) { + } + } + } + done = true; + return futures; + } finally { + if (!done) + for (Future f : futures) + f.cancel(true); + } + } + + public List> invokeAll(Collection> tasks, + long timeout, TimeUnit unit) + throws InterruptedException { + if (tasks == null || unit == null) + throw new NullPointerException(); + long nanos = unit.toNanos(timeout); + List> futures = new ArrayList>(tasks.size()); + boolean done = false; + try { + for (Callable t : tasks) + futures.add(new FutureTask(t)); + + long lastTime = System.nanoTime(); + + // Interleave time checks and calls to execute in case + // executor doesn't have any/much parallelism. + Iterator> 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 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 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 + * head of the queue is that element that has been on the + * queue the longest time. The tail 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. + * + *

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. + * + *

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 true grants threads access in FIFO order. Fairness + * generally decreases throughput but reduces variability and avoids + * starvation. + * + *

This class implements all of the optional methods + * of the {@link Collection} and {@link Iterator} interfaces. + * + *

This class is a member of the + * + * Java Collections Framework. + * + * @since 1.5 + * @author Doug Lea + * @param the type of elements held in this collection + */ +public class ArrayBlockingQueue extends AbstractQueue + implements BlockingQueue, 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 ArrayBlockingQueue with the given (fixed) + * capacity and default access policy. + * @param capacity the capacity of this queue + * @throws IllegalArgumentException if capacity is less than 1 + */ + public ArrayBlockingQueue(int capacity) { + this(capacity, false); + } + + /** + * Creates an ArrayBlockingQueue with the given (fixed) + * capacity and the specified access policy. + * @param capacity the capacity of this queue + * @param fair if true then queue accesses for threads blocked + * on insertion or removal, are processed in FIFO order; if false + * the access order is unspecified. + * @throws IllegalArgumentException if capacity 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 ArrayBlockingQueue 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 true then queue accesses for threads blocked + * on insertion or removal, are processed in FIFO order; if false + * the access order is unspecified. + * @param c the collection of elements to initially contain + * @throws IllegalArgumentException if capacity is less than + * c.size(), or less than 1. + * @throws NullPointerException if c or any element within it + * is null + */ + public ArrayBlockingQueue(int capacity, boolean fair, + Collection c) { + this(capacity, fair); + if (capacity < c.size()) + throw new IllegalArgumentException(); + + for (Iterator 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 true if it was possible to add the element to + * this queue, else false + * @throws NullPointerException if the specified element is null + */ + 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 + * unit + * @param unit a TimeUnit determining how to interpret the + * timeout parameter + * @return true if successful, or false if + * the specified waiting time elapses before space is available. + * @throws InterruptedException if interrupted while waiting. + * @throws NullPointerException if the specified element is null. + */ + 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 null. + */ + 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 size of this queue. + *

Note that you cannot always tell if + * an attempt to add an element will succeed by + * inspecting remainingCapacity because it may be the + * case that a waiting consumer is ready to take 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[] 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 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 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 Iterator 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 iterator() { + final ReentrantLock lock = this.lock; + lock.lock(); + try { + return new Itr(); + } finally { + lock.unlock(); + } + } + + /** + * Iterator for ArrayBlockingQueue + */ + private class Itr implements Iterator { + /** + * 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. + * + *

A BlockingQueue does not accept null elements. + * Implementations throw NullPointerException on attempts + * to add, put or offer a null. A + * null is used as a sentinel value to indicate failure of + * poll operations. + * + *

A BlockingQueue may be capacity bounded. At any given + * time it may have a remainingCapacity beyond which no + * additional elements can be put without blocking. + * A BlockingQueue without any intrinsic capacity constraints always + * reports a remaining capacity of Integer.MAX_VALUE. + * + *

While BlockingQueue 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 + * remove(x). However, such operations are in general + * not 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 addAll, are + * not necessarily performed atomically, so it is possible + * for addAll(c) to fail (throwing an exception) after adding + * only some of the elements in c. + * + *

A BlockingQueue does not 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 + * end-of-stream or poison objects, that are + * interpreted accordingly when taken by consumers. + * + *

+ * Usage example, based on a typical producer-consumer scenario. + * Note that a BlockingQueue can safely be used with multiple + * producers and multiple consumers. + * 

+ * 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();
+ *   }
+ * }
+ *
+ * + *

This interface is a member of the + * + * Java Collections Framework. + * + * @since 1.5 + * @author Doug Lea + * @param the type of elements held in this collection + */ +public interface BlockingQueue extends Queue { + + /** + * Inserts the specified element into this queue, if possible. When + * using queues that may impose insertion restrictions (for + * example capacity bounds), method offer 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 true if it was possible to add the element to + * this queue, else false + * @throws NullPointerException if the specified element is null + */ + 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 + * unit + * @param unit a TimeUnit determining how to interpret the + * timeout parameter + * @return true if successful, or false if + * the specified waiting time elapses before space is available. + * @throws InterruptedException if interrupted while waiting. + * @throws NullPointerException if the specified element is null. + */ + 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 + * unit + * @param unit a TimeUnit determining how to interpret the + * timeout parameter + * @return the head of this queue, or null 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 null. + */ + 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 Integer.MAX_VALUE if there is no + * intrinsic limit. + *

Note that you cannot always tell if + * an attempt to add an element will succeed by + * inspecting remainingCapacity because it may be the + * case that a waiting consumer is ready to take 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 true upon success, else + * throwing an IllegalStateException. + * @param o the element + * @return true (as per the general contract of + * Collection.add). + * + * @throws NullPointerException if the specified element is null + * @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 add elements to + * collection c 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 + * IllegalArgumentException. 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 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 add elements to + * collection c 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 + * IllegalArgumentException. 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 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 BrokenBarrierException with no specified detail + * message. + */ + public BrokenBarrierException() {} + + /** + * Constructs a BrokenBarrierException 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 + * call. + * + *

The Callable interface is similar to {@link + * java.lang.Runnable}, in that both are designed for classes whose + * instances are potentially executed by another thread. A + * Runnable, however, does not return a result and cannot + * throw a checked exception. + * + *

The {@link Executors} class contains utility methods to + * convert from other common forms to Callable classes. + * + * @see Executor + * @since 1.5 + * @author Doug Lea + * @param the result type of method call + */ +public interface Callable { + /** + * 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 CancellationException with no detail message. + */ + public CancellationException() {} + + /** + * Constructs a CancellationException 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 + * submit tasks for execution. Consumers take + * completed tasks and process their results in the order they + * complete. A CompletionService 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. + + *

+ * + * Typically, a CompletionService relies on a separate {@link + * Executor} to actually execute the tasks, in which case the + * CompletionService only manages an internal completion + * queue. The {@link ExecutorCompletionService} class provides an + * implementation of this approach. + * + */ +public interface CompletionService { + /** + * 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 submit(Callable 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 get() method will return the given result value + * upon completion + * @throws RejectedExecutionException if task cannot be scheduled + * for execution + * @throws NullPointerException if task null + */ + Future 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 take() throws InterruptedException; + + + /** + * Retrieves and removes the Future representing the next + * completed task or null if none are present. + * + * @return the Future representing the next completed task, or + * null if none are present. + */ + Future 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 + * unit + * @param unit a TimeUnit determining how to interpret the + * timeout parameter + * @return the Future representing the next completed task or + * null if the specified waiting time elapses before one + * is present. + * @throws InterruptedException if interrupted while waiting. + */ + Future 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