| /* | |
| * Copyright (C) 2014 The Android Open Source Project | |
| * | |
| * 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. | |
| */ | |
| package com.android.camera.async; | |
| import java.util.ArrayList; | |
| import java.util.List; | |
| import java.util.NoSuchElementException; | |
| import java.util.concurrent.BlockingQueue; | |
| import java.util.concurrent.LinkedBlockingQueue; | |
| import java.util.concurrent.TimeUnit; | |
| import java.util.concurrent.TimeoutException; | |
| import java.util.concurrent.atomic.AtomicBoolean; | |
| import javax.annotation.Nonnull; | |
| /** | |
| * A {@link BufferQueue} implementation useful for thread-safe producer-consumer | |
| * interactions.<br> | |
| * Unlike a regular {@link java.util.concurrent.BlockingQueue}, this allows | |
| * closing the queue from either the producer or consumer side and enables | |
| * precise accounting of objects which are never read by the consumer. Notably, | |
| * this enables cleanly shutting down producer-consumer interactions without | |
| * leaking managed resources which might otherwise be left dangling in the | |
| * queue. | |
| */ | |
| public class ConcurrentBufferQueue<T> implements BufferQueue<T>, BufferQueueController<T>, | |
| SafeCloseable { | |
| /** | |
| * A callback to be invoked with all of the elements of the sequence which | |
| * are added but never retrieved via {@link #getNext}. | |
| */ | |
| public static interface UnusedElementProcessor<T> { | |
| /** | |
| * Implementations should properly close the discarded element, if | |
| * necessary. | |
| */ | |
| public void process(T element); | |
| } | |
| /** | |
| * An entry can either be a {@link T} or a special "poison-pill" marker | |
| * indicating that the sequence has been closed. | |
| */ | |
| private static class Entry<T> { | |
| private final T mValue; | |
| private final boolean mClosing; | |
| private Entry(T value, boolean closing) { | |
| mValue = value; | |
| mClosing = closing; | |
| } | |
| public boolean isClosingMarker() { | |
| return mClosing; | |
| } | |
| public T getValue() { | |
| return mValue; | |
| } | |
| } | |
| /** | |
| * Lock used for mQueue modification and mClosed. | |
| */ | |
| private final Object mLock; | |
| /** | |
| * The queue in which to store elements of the sequence as they arrive. | |
| */ | |
| private final BlockingQueue<Entry<T>> mQueue; | |
| /** | |
| * Whether this sequence is closed. | |
| */ | |
| private final AtomicBoolean mClosed; | |
| /** | |
| * The callback to use to process all elements which are discarded by the | |
| * queue. | |
| */ | |
| private final UnusedElementProcessor<T> mUnusedElementProcessor; | |
| public ConcurrentBufferQueue(UnusedElementProcessor<T> unusedElementProcessor) { | |
| mUnusedElementProcessor = unusedElementProcessor; | |
| mLock = new Object(); | |
| mQueue = new LinkedBlockingQueue<>(); | |
| mClosed = new AtomicBoolean(); | |
| } | |
| public ConcurrentBufferQueue() { | |
| // Instantiate with a DiscardedElementProcessor which does nothing. | |
| this(new UnusedElementProcessor<T>() { | |
| @Override | |
| public void process(T element) { | |
| } | |
| }); | |
| } | |
| @Override | |
| public void close() { | |
| List<Entry<T>> remainingElements = new ArrayList<>(); | |
| synchronized (mLock) { | |
| // Mark as closed so that no more threads wait in getNext(). | |
| // Any additional calls to close() will return immediately. | |
| boolean alreadyClosed = mClosed.getAndSet(true); | |
| if (alreadyClosed) { | |
| return; | |
| } | |
| mQueue.drainTo(remainingElements); | |
| // Keep feeding any currently-waiting consumer threads "poison pill" | |
| // {@link Entry}s indicating that the sequence has ended so they | |
| // wake up. When no more threads are waiting for another value from | |
| // mQueue, the call to peek() from this thread will see a value. | |
| // Note that this also ensures that there is a poison pill in the | |
| // queue | |
| // to keep waking-up any threads which manage to block in getNext() | |
| // even after marking mClosed. | |
| while (mQueue.peek() == null) { | |
| mQueue.add(makeClosingMarker()); | |
| } | |
| } | |
| for (Entry<T> entry : remainingElements) { | |
| if (!entry.isClosingMarker()) { | |
| mUnusedElementProcessor.process(entry.getValue()); | |
| } | |
| } | |
| } | |
| @Override | |
| public void update(@Nonnull T element) { | |
| boolean closed = false; | |
| synchronized (mLock) { | |
| closed = mClosed.get(); | |
| if (!closed) { | |
| mQueue.add(makeEntry(element)); | |
| } | |
| } | |
| if (closed) { | |
| mUnusedElementProcessor.process(element); | |
| } | |
| } | |
| private T doWithNextEntry(Entry<T> nextEntry) throws BufferQueueClosedException { | |
| if (nextEntry.isClosingMarker()) { | |
| // Always keep a poison-pill in the queue to avoid a race condition | |
| // in which a thread reaches the mQueue.take() call after close(). | |
| mQueue.add(nextEntry); | |
| throw new BufferQueueClosedException(); | |
| } else { | |
| return nextEntry.getValue(); | |
| } | |
| } | |
| @Override | |
| public T getNext() throws InterruptedException, BufferQueueClosedException { | |
| Entry<T> nextEntry = mQueue.take(); | |
| return doWithNextEntry(nextEntry); | |
| } | |
| @Override | |
| public T getNext(long timeout, TimeUnit unit) throws InterruptedException, TimeoutException, | |
| BufferQueueClosedException { | |
| Entry<T> nextEntry = mQueue.poll(timeout, unit); | |
| if (nextEntry == null) { | |
| throw new TimeoutException(); | |
| } | |
| return doWithNextEntry(nextEntry); | |
| } | |
| @Override | |
| public T peekNext() { | |
| Entry<T> nextEntry = mQueue.peek(); | |
| if (nextEntry == null) { | |
| return null; | |
| } else if (nextEntry.isClosingMarker()) { | |
| return null; | |
| } else { | |
| return nextEntry.getValue(); | |
| } | |
| } | |
| @Override | |
| public void discardNext() { | |
| try { | |
| Entry<T> nextEntry = mQueue.remove(); | |
| if (nextEntry.isClosingMarker()) { | |
| // Always keep a poison-pill in the queue to avoid a race | |
| // condition in which a thread reaches the mQueue.take() call | |
| // after close(). | |
| mQueue.add(nextEntry); | |
| } else { | |
| mUnusedElementProcessor.process(nextEntry.getValue()); | |
| } | |
| } catch (NoSuchElementException e) { | |
| // If the queue is already empty, do nothing. | |
| return; | |
| } | |
| } | |
| @Override | |
| public boolean isClosed() { | |
| return mClosed.get(); | |
| } | |
| private Entry makeEntry(T value) { | |
| return new Entry(value, false); | |
| } | |
| private Entry makeClosingMarker() { | |
| return new Entry(null, true); | |
| } | |
| } |