java.nio.channels.spi.AbstractSelector Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-all Show documentation
A library jar that provides APIs for Applications written for the Google Android Platform.
There is a newer version: 14-robolectric-10818077
/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You 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 java.nio.channels.spi;

import java.io.IOException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * {@code AbstractSelector} is the base implementation class for selectors.
 * It realizes the interruption of selection by {@code begin} and
 * {@code end}. It also holds the cancellation and the deletion of the key
 * set.
 */
public abstract class AbstractSelector extends Selector {
    private final AtomicBoolean isOpen = new AtomicBoolean(true);

    private SelectorProvider provider = null;

    private final Set cancelledKeysSet = new HashSet();

    private final Runnable wakeupRunnable = new Runnable() {
        @Override public void run() {
            wakeup();
        }
    };

    protected AbstractSelector(SelectorProvider selectorProvider) {
        provider = selectorProvider;
    }

    /**
     * Closes this selector. This method does nothing if this selector is
     * already closed. The actual closing must be implemented by subclasses in
     * {@code implCloseSelector()}.
     */
    @Override
    public final void close() throws IOException {
        if (isOpen.getAndSet(false)) {
            implCloseSelector();
        }
    }

    /**
     * Implements the closing of this channel.
     */
    protected abstract void implCloseSelector() throws IOException;

    /**
     * Returns true if this selector is open.
     */
    @Override
    public final boolean isOpen() {
        return isOpen.get();
    }

    /**
     * Returns this selector's provider.
     */
    @Override
    public final SelectorProvider provider() {
        return provider;
    }

    /**
     * Returns this channel's set of canceled selection keys.
     */
    protected final Set cancelledKeys() {
        return cancelledKeysSet;
    }

    /**
     * Registers {@code channel} with this selector.
     *
     * @param operations the {@link SelectionKey interest set} of {@code
     *     channel}.
     * @param attachment the attachment for the selection key.
     * @return the key related to the channel and this selector.
     */
    protected abstract SelectionKey register(AbstractSelectableChannel channel,
            int operations, Object attachment);

    /**
     * Deletes the key from the channel's key set.
     */
    protected final void deregister(AbstractSelectionKey key) {
        ((AbstractSelectableChannel) key.channel()).deregister(key);
        key.isValid = false;
    }

    /**
     * Indicates the beginning of a code section that includes an I/O operation
     * that is potentially blocking. After this operation, the application
     * should invoke the corresponding {@code end(boolean)} method.
     */
    protected final void begin() {
        Thread.currentThread().pushInterruptAction$(wakeupRunnable);
    }

    /**
     * Indicates the end of a code section that has been started with
     * {@code begin()} and that includes a potentially blocking I/O operation.
     */
    protected final void end() {
        Thread.currentThread().popInterruptAction$(wakeupRunnable);
    }

    void cancel(SelectionKey key) {
        synchronized (cancelledKeysSet) {
            cancelledKeysSet.add(key);
        }
    }
}