harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ndbe...@apache.org
Subject svn commit: r442038 [1/19] - in /incubator/harmony/standard/classlib/trunk/modules/concurrent: ./ src/ src/main/ src/main/java/ src/main/java/java/ src/main/java/java/util/ src/main/java/java/util/concurrent/ src/main/java/java/util/concurrent/atomic/ ...
Date Sun, 10 Sep 2006 23:59:35 GMT
Author: ndbeyer
Date: Sun Sep 10 16:59:30 2006
New Revision: 442038

URL: http://svn.apache.org/viewvc?view=rev&rev=442038
Log:
Add concurrent module

Added:
    incubator/harmony/standard/classlib/trunk/modules/concurrent/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ConcurrentHashMap.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ConcurrentMap.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CopyOnWriteArraySet.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CountDownLatch.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CyclicBarrier.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/DelayQueue.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Delayed.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Exchanger.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ExecutionException.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Executor.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ExecutorCompletionService.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ExecutorService.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Executors.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Future.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/FutureTask.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/LinkedBlockingQueue.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/PriorityBlockingQueue.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/RejectedExecutionException.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/RejectedExecutionHandler.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ScheduledExecutorService.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ScheduledFuture.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ScheduledThreadPoolExecutor.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Semaphore.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/SynchronousQueue.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ThreadFactory.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ThreadPoolExecutor.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/TimeUnit.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/TimeoutException.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicBoolean.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicInteger.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicIntegerArray.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLong.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLongArray.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicLongFieldUpdater.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicMarkableReference.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReference.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReferenceArray.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/AtomicStampedReference.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/atomic/package.html   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/Condition.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/Lock.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/LockSupport.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/ReadWriteLock.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/ReentrantLock.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/locks/package.html   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/package.html   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/resources/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AbstractExecutorServiceTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AbstractQueueTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AbstractQueuedSynchronizerTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ArrayBlockingQueueTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicBooleanTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicIntegerArrayTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicIntegerFieldUpdaterTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicIntegerTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicLongArrayTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicLongFieldUpdaterTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicLongTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicMarkableReferenceTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicReferenceArrayTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicReferenceFieldUpdaterTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicReferenceTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/AtomicStampedReferenceTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ConcurrentHashMapTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ConcurrentLinkedQueueTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/CopyOnWriteArrayListTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/CopyOnWriteArraySetTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/CountDownLatchTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/CyclicBarrierTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/DelayQueueTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExchangerTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorCompletionServiceTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ExecutorsTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/FutureTaskTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/JSR166TestCase.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/LinkedBlockingQueueTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/LinkedListTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/LockSupportTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/PriorityBlockingQueueTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/PriorityQueueTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ReentrantLockTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ReentrantReadWriteLockTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ScheduledExecutorTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/SemaphoreTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/SynchronousQueueTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/SystemTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadLocalTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadPoolExecutorTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/TimeUnitTest.java   (with props)
    incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/resources/

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java Sun Sep 10 16:59:30 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/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/AbstractExecutorService.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java Sun Sep 10 16:59:30 2006
@@ -0,0 +1,685 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ */
+
+package java.util.concurrent;
+import java.util.concurrent.locks.*;
+import java.util.*;
+
+/**
+ * A bounded {@linkplain BlockingQueue blocking queue} backed by an
+ * array.  This queue orders elements FIFO (first-in-first-out).  The
+ * <em>head</em> of the queue is that element that has been on the
+ * queue the longest time.  The <em>tail</em> of the queue is that
+ * element that has been on the queue the shortest time. New elements
+ * are inserted at the tail of the queue, and the queue retrieval
+ * operations obtain elements at the head of the queue.
+ *
+ * <p>This is a classic &quot;bounded buffer&quot;, in which a
+ * fixed-sized array holds elements inserted by producers and
+ * extracted by consumers.  Once created, the capacity cannot be
+ * increased.  Attempts to offer an element to a full queue will
+ * result in the offer operation blocking; attempts to retrieve an
+ * element from an empty queue will similarly block.
+ *
+ * <p> This class supports an optional fairness policy for ordering
+ * waiting producer and consumer threads.  By default, this ordering
+ * is not guaranteed. However, a queue constructed with fairness set
+ * to <tt>true</tt> grants threads access in FIFO order. Fairness
+ * generally decreases throughput but reduces variability and avoids
+ * starvation.
+ *
+ * <p>This class implements all of the <em>optional</em> methods
+ * of the {@link Collection} and {@link Iterator} interfaces.
+ *
+ * <p>This class is a member of the
+ * <a href="{@docRoot}/../guide/collections/index.html">
+ * Java Collections Framework</a>.
+ *
+ * @since 1.5
+ * @author Doug Lea
+ * @param <E> the type of elements held in this collection
+ */
+public class ArrayBlockingQueue<E> extends AbstractQueue<E>
+        implements BlockingQueue<E>, java.io.Serializable {
+
+    /**
+     * Serialization ID. This class relies on default serialization
+     * even for the items array, which is default-serialized, even if
+     * it is empty. Otherwise it could not be declared final, which is
+     * necessary here.
+     */
+    private static final long serialVersionUID = -817911632652898426L;
+
+    /** The queued items  */
+    private final E[] items;
+    /** items index for next take, poll or remove */
+    private transient int takeIndex;
+    /** items index for next put, offer, or add. */
+    private transient int putIndex;
+    /** Number of items in the queue */
+    private int count;
+
+    /*
+     * Concurrency control uses the classic two-condition algorithm
+     * found in any textbook.
+     */
+
+    /** Main lock guarding all access */
+    private final ReentrantLock lock;
+    /** Condition for waiting takes */
+    private final Condition notEmpty;
+    /** Condition for waiting puts */
+    private final Condition notFull;
+
+    // Internal helper methods
+
+    /**
+     * Circularly increment i.
+     */
+    final int inc(int i) {
+        return (++i == items.length)? 0 : i;
+    }
+
+    /**
+     * Insert element at current put position, advance, and signal.
+     * Call only when holding lock.
+     */
+    private void insert(E x) {
+        items[putIndex] = x;
+        putIndex = inc(putIndex);
+        ++count;
+        notEmpty.signal();
+    }
+
+    /**
+     * Extract element at current take position, advance, and signal.
+     * Call only when holding lock.
+     */
+    private E extract() {
+        final E[] items = this.items;
+        E x = items[takeIndex];
+        items[takeIndex] = null;
+        takeIndex = inc(takeIndex);
+        --count;
+        notFull.signal();
+        return x;
+    }
+
+    /**
+     * Utility for remove and iterator.remove: Delete item at position i.
+     * Call only when holding lock.
+     */
+    void removeAt(int i) {
+        final E[] items = this.items;
+        // if removing front item, just advance
+        if (i == takeIndex) {
+            items[takeIndex] = null;
+            takeIndex = inc(takeIndex);
+        } else {
+            // slide over all others up through putIndex.
+            for (;;) {
+                int nexti = inc(i);
+                if (nexti != putIndex) {
+                    items[i] = items[nexti];
+                    i = nexti;
+                } else {
+                    items[i] = null;
+                    putIndex = i;
+                    break;
+                }
+            }
+        }
+        --count;
+        notFull.signal();
+    }
+
+    /**
+     * Creates an <tt>ArrayBlockingQueue</tt> with the given (fixed)
+     * capacity and default access policy.
+     * @param capacity the capacity of this queue
+     * @throws IllegalArgumentException if <tt>capacity</tt> is less than 1
+     */
+    public ArrayBlockingQueue(int capacity) {
+        this(capacity, false);
+    }
+
+    /**
+     * Creates an <tt>ArrayBlockingQueue</tt> with the given (fixed)
+     * capacity and the specified access policy.
+     * @param capacity the capacity of this queue
+     * @param fair if <tt>true</tt> then queue accesses for threads blocked
+     * on insertion or removal, are processed in FIFO order; if <tt>false</tt>
+     * the access order is unspecified.
+     * @throws IllegalArgumentException if <tt>capacity</tt> is less than 1
+     */
+    public ArrayBlockingQueue(int capacity, boolean fair) {
+        if (capacity <= 0)
+            throw new IllegalArgumentException();
+        this.items = (E[]) new Object[capacity];
+        lock = new ReentrantLock(fair);
+        notEmpty = lock.newCondition();
+        notFull =  lock.newCondition();
+    }
+
+    /**
+     * Creates an <tt>ArrayBlockingQueue</tt> with the given (fixed)
+     * capacity, the specified access policy and initially containing the
+     * elements of the given collection,
+     * added in traversal order of the collection's iterator.
+     * @param capacity the capacity of this queue
+     * @param fair if <tt>true</tt> then queue accesses for threads blocked
+     * on insertion or removal, are processed in FIFO order; if <tt>false</tt>
+     * the access order is unspecified.
+     * @param c the collection of elements to initially contain
+     * @throws IllegalArgumentException if <tt>capacity</tt> is less than
+     * <tt>c.size()</tt>, or less than 1.
+     * @throws NullPointerException if <tt>c</tt> or any element within it
+     * is <tt>null</tt>
+     */
+    public ArrayBlockingQueue(int capacity, boolean fair,
+                              Collection<? extends E> c) {
+        this(capacity, fair);
+        if (capacity < c.size())
+            throw new IllegalArgumentException();
+
+        for (Iterator<? extends E> it = c.iterator(); it.hasNext();)
+            add(it.next());
+    }
+
+    /**
+     * Inserts the specified element at the tail of this queue if possible,
+     * returning immediately if this queue is full.
+     *
+     * @param o the element to add.
+     * @return <tt>true</tt> if it was possible to add the element to
+     *         this queue, else <tt>false</tt>
+     * @throws NullPointerException if the specified element is <tt>null</tt>
+     */
+    public boolean offer(E o) {
+        if (o == null) throw new NullPointerException();
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            if (count == items.length)
+                return false;
+            else {
+                insert(o);
+                return true;
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Inserts the specified element at the tail of this queue, waiting if
+     * necessary up to the specified wait time for space to become available.
+     * @param o the element to add
+     * @param timeout how long to wait before giving up, in units of
+     * <tt>unit</tt>
+     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
+     * <tt>timeout</tt> parameter
+     * @return <tt>true</tt> if successful, or <tt>false</tt> if
+     * the specified waiting time elapses before space is available.
+     * @throws InterruptedException if interrupted while waiting.
+     * @throws NullPointerException if the specified element is <tt>null</tt>.
+     */
+    public boolean offer(E o, long timeout, TimeUnit unit)
+        throws InterruptedException {
+
+        if (o == null) throw new NullPointerException();
+        final ReentrantLock lock = this.lock;
+        lock.lockInterruptibly();
+        try {
+            long nanos = unit.toNanos(timeout);
+            for (;;) {
+                if (count != items.length) {
+                    insert(o);
+                    return true;
+                }
+                if (nanos <= 0)
+                    return false;
+                try {
+                    nanos = notFull.awaitNanos(nanos);
+                } catch (InterruptedException ie) {
+                    notFull.signal(); // propagate to non-interrupted thread
+                    throw ie;
+                }
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    public E poll() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            if (count == 0)
+                return null;
+            E x = extract();
+            return x;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public E poll(long timeout, TimeUnit unit) throws InterruptedException {
+        final ReentrantLock lock = this.lock;
+        lock.lockInterruptibly();
+        try {
+            long nanos = unit.toNanos(timeout);
+            for (;;) {
+                if (count != 0) {
+                    E x = extract();
+                    return x;
+                }
+                if (nanos <= 0)
+                    return null;
+                try {
+                    nanos = notEmpty.awaitNanos(nanos);
+                } catch (InterruptedException ie) {
+                    notEmpty.signal(); // propagate to non-interrupted thread
+                    throw ie;
+                }
+
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    public boolean remove(Object o) {
+        if (o == null) return false;
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            int i = takeIndex;
+            int k = 0;
+            for (;;) {
+                if (k++ >= count)
+                    return false;
+                if (o.equals(items[i])) {
+                    removeAt(i);
+                    return true;
+                }
+                i = inc(i);
+            }
+
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public E peek() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            return (count == 0) ? null : items[takeIndex];
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public E take() throws InterruptedException {
+        final ReentrantLock lock = this.lock;
+        lock.lockInterruptibly();
+        try {
+            try {
+                while (count == 0)
+                    notEmpty.await();
+            } catch (InterruptedException ie) {
+                notEmpty.signal(); // propagate to non-interrupted thread
+                throw ie;
+            }
+            E x = extract();
+            return x;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Adds the specified element to the tail of this queue, waiting if
+     * necessary for space to become available.
+     * @param o the element to add
+     * @throws InterruptedException if interrupted while waiting.
+     * @throws NullPointerException if the specified element is <tt>null</tt>.
+     */
+    public void put(E o) throws InterruptedException {
+        if (o == null) throw new NullPointerException();
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lockInterruptibly();
+        try {
+            try {
+                while (count == items.length)
+                    notFull.await();
+            } catch (InterruptedException ie) {
+                notFull.signal(); // propagate to non-interrupted thread
+                throw ie;
+            }
+            insert(o);
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    // this doc comment is overridden to remove the reference to collections
+    // greater in size than Integer.MAX_VALUE
+    /**
+     * Returns the number of elements in this queue.
+     *
+     * @return  the number of elements in this queue.
+     */
+    public int size() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            return count;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    // this doc comment is a modified copy of the inherited doc comment,
+    // without the reference to unlimited queues.
+    /**
+     * Returns the number of elements that this queue can ideally (in
+     * the absence of memory or resource constraints) accept without
+     * blocking. This is always equal to the initial capacity of this queue
+     * less the current <tt>size</tt> of this queue.
+     * <p>Note that you <em>cannot</em> always tell if
+     * an attempt to <tt>add</tt> an element will succeed by
+     * inspecting <tt>remainingCapacity</tt> because it may be the
+     * case that a waiting consumer is ready to <tt>take</tt> an
+     * element out of an otherwise full queue.
+     */
+    public int remainingCapacity() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            return items.length - count;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    public boolean contains(Object o) {
+        if (o == null) return false;
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            int i = takeIndex;
+            int k = 0;
+            while (k++ < count) {
+                if (o.equals(items[i]))
+                    return true;
+                i = inc(i);
+            }
+            return false;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public Object[] toArray() {
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            Object[] a = new Object[count];
+            int k = 0;
+            int i = takeIndex;
+            while (k < count) {
+                a[k++] = items[i];
+                i = inc(i);
+            }
+            return a;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public <T> T[] toArray(T[] a) {
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            if (a.length < count)
+                a = (T[])java.lang.reflect.Array.newInstance(
+                    a.getClass().getComponentType(),
+                    count
+                    );
+
+            int k = 0;
+            int i = takeIndex;
+            while (k < count) {
+                a[k++] = (T)items[i];
+                i = inc(i);
+            }
+            if (a.length > count)
+                a[count] = null;
+            return a;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public String toString() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            return super.toString();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    public void clear() {
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            int i = takeIndex;
+            int k = count;
+            while (k-- > 0) {
+                items[i] = null;
+                i = inc(i);
+            }
+            count = 0;
+            putIndex = 0;
+            takeIndex = 0;
+            notFull.signalAll();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public int drainTo(Collection<? super E> c) {
+        if (c == null)
+            throw new NullPointerException();
+        if (c == this)
+            throw new IllegalArgumentException();
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            int i = takeIndex;
+            int n = 0;
+            int max = count;
+            while (n < max) {
+                c.add(items[i]);
+                items[i] = null;
+                i = inc(i);
+                ++n;
+            }
+            if (n > 0) {
+                count = 0;
+                putIndex = 0;
+                takeIndex = 0;
+                notFull.signalAll();
+            }
+            return n;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    public int drainTo(Collection<? super E> c, int maxElements) {
+        if (c == null)
+            throw new NullPointerException();
+        if (c == this)
+            throw new IllegalArgumentException();
+        if (maxElements <= 0)
+            return 0;
+        final E[] items = this.items;
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            int i = takeIndex;
+            int n = 0;
+            int sz = count;
+            int max = (maxElements < count)? maxElements : count;
+            while (n < max) {
+                c.add(items[i]);
+                items[i] = null;
+                i = inc(i);
+                ++n;
+            }
+            if (n > 0) {
+                count -= n;
+                takeIndex = i;
+                notFull.signalAll();
+            }
+            return n;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+    /**
+     * Returns an iterator over the elements in this queue in proper sequence.
+     * The returned <tt>Iterator</tt> is a "weakly consistent" iterator that
+     * will never throw {@link java.util.ConcurrentModificationException},
+     * and guarantees to traverse elements as they existed upon
+     * construction of the iterator, and may (but is not guaranteed to)
+     * reflect any modifications subsequent to construction.
+     *
+     * @return an iterator over the elements in this queue in proper sequence.
+     */
+    public Iterator<E> iterator() {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            return new Itr();
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Iterator for ArrayBlockingQueue
+     */
+    private class Itr implements Iterator<E> {
+        /**
+         * Index of element to be returned by next,
+         * or a negative number if no such.
+         */
+        private int nextIndex;
+
+        /**
+         * nextItem holds on to item fields because once we claim
+         * that an element exists in hasNext(), we must return it in
+         * the following next() call even if it was in the process of
+         * being removed when hasNext() was called.
+         **/
+        private E nextItem;
+
+        /**
+         * Index of element returned by most recent call to next.
+         * Reset to -1 if this element is deleted by a call to remove.
+         */
+        private int lastRet;
+
+        Itr() {
+            lastRet = -1;
+            if (count == 0)
+                nextIndex = -1;
+            else {
+                nextIndex = takeIndex;
+                nextItem = items[takeIndex];
+            }
+        }
+
+        public boolean hasNext() {
+            /*
+             * No sync. We can return true by mistake here
+             * only if this iterator passed across threads,
+             * which we don't support anyway.
+             */
+            return nextIndex >= 0;
+        }
+
+        /**
+         * Check whether nextIndex is valid; if so setting nextItem.
+         * Stops iterator when either hits putIndex or sees null item.
+         */
+        private void checkNext() {
+            if (nextIndex == putIndex) {
+                nextIndex = -1;
+                nextItem = null;
+            } else {
+                nextItem = items[nextIndex];
+                if (nextItem == null)
+                    nextIndex = -1;
+            }
+        }
+
+        public E next() {
+            final ReentrantLock lock = ArrayBlockingQueue.this.lock;
+            lock.lock();
+            try {
+                if (nextIndex < 0)
+                    throw new NoSuchElementException();
+                lastRet = nextIndex;
+                E x = nextItem;
+                nextIndex = inc(nextIndex);
+                checkNext();
+                return x;
+            } finally {
+                lock.unlock();
+            }
+        }
+
+        public void remove() {
+            final ReentrantLock lock = ArrayBlockingQueue.this.lock;
+            lock.lock();
+            try {
+                int i = lastRet;
+                if (i == -1)
+                    throw new IllegalStateException();
+                lastRet = -1;
+
+                int ti = takeIndex;
+                removeAt(i);
+                // back up cursor (reset to front if was first element)
+                nextIndex = (i == ti) ? takeIndex : i;
+                checkNext();
+            } finally {
+                lock.unlock();
+            }
+        }
+    }
+}

Propchange: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java Sun Sep 10 16:59:30 2006
@@ -0,0 +1,227 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/licenses/publicdomain
+ */
+
+package java.util.concurrent;
+
+import java.util.Collection;
+import java.util.Queue;
+
+/**
+ * A {@link java.util.Queue} that additionally supports operations
+ * that wait for the queue to become non-empty when retrieving an element,
+ * and wait for space to become available in the queue when storing an 
+ * element.
+ *
+ * <p>A <tt>BlockingQueue</tt> does not accept <tt>null</tt> elements.
+ * Implementations throw <tt>NullPointerException</tt> on attempts
+ * to <tt>add</tt>, <tt>put</tt> or <tt>offer</tt> a <tt>null</tt>.  A
+ * <tt>null</tt> is used as a sentinel value to indicate failure of
+ * <tt>poll</tt> operations.
+ *
+ * <p>A <tt>BlockingQueue</tt> may be capacity bounded. At any given
+ * time it may have a <tt>remainingCapacity</tt> beyond which no
+ * additional elements can be <tt>put</tt> without blocking.
+ * A <tt>BlockingQueue</tt> without any intrinsic capacity constraints always
+ * reports a remaining capacity of <tt>Integer.MAX_VALUE</tt>.
+ *
+ * <p> While <tt>BlockingQueue</tt> is designed to be used primarily
+ * for producer-consumer queues, it additionally supports the {@link
+ * java.util.Collection} interface.  So, for example, it is possible
+ * to remove an arbitrary element from a queue using
+ * <tt>remove(x)</tt>. However, such operations are in general
+ * <em>not</em> performed very efficiently, and are intended for only
+ * occasional use, such as when a queued message is cancelled.  Also,
+ * the bulk Collection operations, most notably <tt>addAll</tt>, are
+ * <em>not</em> necessarily performed atomically, so it is possible
+ * for <tt>addAll(c)</tt> to fail (throwing an exception) after adding
+ * only some of the elements in <tt>c</tt>.
+ *
+ * <p>A <tt>BlockingQueue</tt> does <em>not</em> intrinsically support
+ * any kind of &quot;close&quot; or &quot;shutdown&quot; operation to
+ * indicate that no more items will be added.  The needs and usage of
+ * such features tend to be implementation-dependent. For example, a
+ * common tactic is for producers to insert special
+ * <em>end-of-stream</em> or <em>poison</em> objects, that are
+ * interpreted accordingly when taken by consumers.
+ *
+ * <p>
+ * Usage example, based on a typical producer-consumer scenario.
+ * Note that a <tt>BlockingQueue</tt> can safely be used with multiple
+ * producers and multiple consumers.
+ * <pre>
+ * class Producer implements Runnable {
+ *   private final BlockingQueue queue;
+ *   Producer(BlockingQueue q) { queue = q; }
+ *   public void run() {
+ *     try {
+ *       while(true) { queue.put(produce()); }
+ *     } catch (InterruptedException ex) { ... handle ...}
+ *   }
+ *   Object produce() { ... }
+ * }
+ *
+ * class Consumer implements Runnable {
+ *   private final BlockingQueue queue;
+ *   Consumer(BlockingQueue q) { queue = q; }
+ *   public void run() {
+ *     try {
+ *       while(true) { consume(queue.take()); }
+ *     } catch (InterruptedException ex) { ... handle ...}
+ *   }
+ *   void consume(Object x) { ... }
+ * }
+ *
+ * class Setup {
+ *   void main() {
+ *     BlockingQueue q = new SomeQueueImplementation();
+ *     Producer p = new Producer(q);
+ *     Consumer c1 = new Consumer(q);
+ *     Consumer c2 = new Consumer(q);
+ *     new Thread(p).start();
+ *     new Thread(c1).start();
+ *     new Thread(c2).start();
+ *   }
+ * }
+ * </pre>
+ *
+ * <p>This interface is a member of the
+ * <a href="{@docRoot}/../guide/collections/index.html">
+ * Java Collections Framework</a>.
+ *  
+ * @since 1.5
+ * @author Doug Lea
+ * @param <E> the type of elements held in this collection
+ */
+public interface BlockingQueue<E> extends Queue<E> {
+
+    /**
+     * Inserts the specified element into this queue, if possible.  When
+     * using queues that may impose insertion restrictions (for
+     * example capacity bounds), method <tt>offer</tt> is generally
+     * preferable to method {@link Collection#add}, which can fail to
+     * insert an element only by throwing an exception.
+     *
+     * @param o the element to add.
+     * @return <tt>true</tt> if it was possible to add the element to
+     *         this queue, else <tt>false</tt>
+     * @throws NullPointerException if the specified element is <tt>null</tt>
+     */
+    boolean offer(E o);
+    
+    /**
+     * Inserts the specified element into this queue, waiting if necessary
+     * up to the specified wait time for space to become available.
+     * @param o the element to add
+     * @param timeout how long to wait before giving up, in units of
+     * <tt>unit</tt>
+     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
+     * <tt>timeout</tt> parameter
+     * @return <tt>true</tt> if successful, or <tt>false</tt> if
+     * the specified waiting time elapses before space is available.
+     * @throws InterruptedException if interrupted while waiting.
+     * @throws NullPointerException if the specified element is <tt>null</tt>.
+     */
+    boolean offer(E o, long timeout, TimeUnit unit)
+        throws InterruptedException;
+
+    /**
+     * Retrieves and removes the head of this queue, waiting
+     * if necessary up to the specified wait time if no elements are
+     * present on this queue.
+     * @param timeout how long to wait before giving up, in units of
+     * <tt>unit</tt>
+     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
+     * <tt>timeout</tt> parameter
+     * @return the head of this queue, or <tt>null</tt> if the
+     * specified waiting time elapses before an element is present.
+     * @throws InterruptedException if interrupted while waiting.
+     */
+    E poll(long timeout, TimeUnit unit)
+        throws InterruptedException;
+
+    /**
+     * Retrieves and removes the head of this queue, waiting
+     * if no elements are present on this queue.
+     * @return the head of this queue
+     * @throws InterruptedException if interrupted while waiting.
+     */
+    E take() throws InterruptedException;
+
+    /**
+     * Adds the specified element to this queue, waiting if necessary for
+     * space to become available.
+     * @param o the element to add
+     * @throws InterruptedException if interrupted while waiting.
+     * @throws NullPointerException if the specified element is <tt>null</tt>.
+     */
+    void put(E o) throws InterruptedException;
+
+    /**
+     * Returns the number of elements that this queue can ideally (in
+     * the absence of memory or resource constraints) accept without
+     * blocking, or <tt>Integer.MAX_VALUE</tt> if there is no
+     * intrinsic limit.
+     * <p>Note that you <em>cannot</em> always tell if
+     * an attempt to <tt>add</tt> an element will succeed by
+     * inspecting <tt>remainingCapacity</tt> because it may be the
+     * case that a waiting consumer is ready to <tt>take</tt> an
+     * element out of an otherwise full queue.
+     * @return the remaining capacity
+     */
+    int remainingCapacity();
+
+    /**
+     * Adds the specified element to this queue if it is possible to
+     * do so immediately, returning <tt>true</tt> upon success, else
+     * throwing an IllegalStateException.  
+     * @param o the element
+     * @return <tt>true</tt> (as per the general contract of
+     *         <tt>Collection.add</tt>).
+     *
+     * @throws NullPointerException if the specified element is <tt>null</tt>
+     * @throws IllegalStateException if element cannot be added
+     */
+    boolean add(E o);
+
+    /**
+     * Removes all available elements from this queue and adds them
+     * into the given collection.  This operation may be more
+     * efficient than repeatedly polling this queue.  A failure
+     * encountered while attempting to <tt>add</tt> elements to
+     * collection <tt>c</tt> may result in elements being in neither,
+     * either or both collections when the associated exception is
+     * thrown. Attempts to drain a queue to itself result in
+     * <tt>IllegalArgumentException</tt>. Further, the behavior of
+     * this operation is undefined if the specified collection is
+     * modified while the operation is in progress.
+     *
+     * @param c the collection to transfer elements into
+     * @return the number of elements transferred.
+     * @throws NullPointerException if c is null
+     * @throws IllegalArgumentException if c is this queue
+     * 
+     */
+    int drainTo(Collection<? super E> c);
+    
+    /**
+     * Removes at most the given number of available elements from
+     * this queue and adds them into the given collection.  A failure
+     * encountered while attempting to <tt>add</tt> elements to
+     * collection <tt>c</tt> may result in elements being in neither,
+     * either or both collections when the associated exception is
+     * thrown. Attempts to drain a queue to itself result in
+     * <tt>IllegalArgumentException</tt>. Further, the behavior of
+     * this operation is undefined if the specified collection is
+     * modified while the operation is in progress.
+     *
+     * @param c the collection to transfer elements into
+     * @param maxElements the maximum number of elements to transfer
+     * @return the number of elements transferred.
+     * @throws NullPointerException if c is null
+     * @throws IllegalArgumentException if c is this queue
+     */
+    int drainTo(Collection<? super E> c, int maxElements);
+}

Propchange: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BlockingQueue.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java Sun Sep 10 16:59:30 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/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/BrokenBarrierException.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java Sun Sep 10 16:59:30 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/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/Callable.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java Sun Sep 10 16:59:30 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/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CancellationException.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java Sun Sep 10 16:59:30 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/standard/classlib/trunk/modules/concurrent/src/main/java/java/util/concurrent/CompletionService.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message