feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/java/nio/channels/spi/AbstractSelector.java

@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+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 sun.nio.ch.Interruptible;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+
+/**
+ * Base implementation class for selectors.
+ *
+ * <p> This class encapsulates the low-level machinery required to implement
+ * the interruption of selection operations.  A concrete selector class must
+ * invoke the {@link #begin begin} and {@link #end end} methods before and
+ * after, respectively, invoking an I/O operation that might block
+ * indefinitely.  In order to ensure that the {@link #end end} method is always
+ * invoked, these methods should be used within a
+ * <tt>try</tt>&nbsp;...&nbsp;<tt>finally</tt> block:
+ *
+ * <blockquote><pre>
+ * try {
+ *     begin();
+ *     // Perform blocking I/O operation here
+ *     ...
+ * } finally {
+ *     end();
+ * }</pre></blockquote>
+ *
+ * <p> This class also defines methods for maintaining a selector's
+ * cancelled-key set and for removing a key from its channel's key set, and
+ * declares the abstract {@link #register register} method that is invoked by a
+ * selectable channel's {@link AbstractSelectableChannel#register register}
+ * method in order to perform the actual work of registering a channel.  </p>
+ *
+ *
+ * @author Mark Reinhold
+ * @author JSR-51 Expert Group
+ * @since 1.4
+ */
+
+public abstract class AbstractSelector
+    extends Selector
+{
+
+    private AtomicBoolean selectorOpen = new AtomicBoolean(true);
+
+    // The provider that created this selector
+    private final SelectorProvider provider;
+
+    /**
+     * Initializes a new instance of this class.
+     *
+     * @param  provider
+     *         The provider that created this selector
+     */
+    protected AbstractSelector(SelectorProvider provider) {
+        this.provider = provider;
+    }
+
+    private final Set<SelectionKey> cancelledKeys = new HashSet<SelectionKey>();
+
+    void cancel(SelectionKey k) {                       // package-private
+        synchronized (cancelledKeys) {
+            cancelledKeys.add(k);
+        }
+    }
+
+    /**
+     * Closes this selector.
+     *
+     * <p> If the selector has already been closed then this method returns
+     * immediately.  Otherwise it marks the selector as closed and then invokes
+     * the {@link #implCloseSelector implCloseSelector} method in order to
+     * complete the close operation.  </p>
+     *
+     * @throws  IOException
+     *          If an I/O error occurs
+     */
+    public final void close() throws IOException {
+        boolean open = selectorOpen.getAndSet(false);
+        if (!open)
+            return;
+        implCloseSelector();
+    }
+
+    /**
+     * Closes this selector.
+     *
+     * <p> This method is invoked by the {@link #close close} method in order
+     * to perform the actual work of closing the selector.  This method is only
+     * invoked if the selector has not yet been closed, and it is never invoked
+     * more than once.
+     *
+     * <p> An implementation of this method must arrange for any other thread
+     * that is blocked in a selection operation upon this selector to return
+     * immediately as if by invoking the {@link
+     * java.nio.channels.Selector#wakeup wakeup} method. </p>
+     *
+     * @throws  IOException
+     *          If an I/O error occurs while closing the selector
+     */
+    protected abstract void implCloseSelector() throws IOException;
+
+    public final boolean isOpen() {
+        return selectorOpen.get();
+    }
+
+    /**
+     * Returns the provider that created this channel.
+     *
+     * @return  The provider that created this channel
+     */
+    public final SelectorProvider provider() {
+        return provider;
+    }
+
+    /**
+     * Retrieves this selector's cancelled-key set.
+     *
+     * <p> This set should only be used while synchronized upon it.  </p>
+     *
+     * @return  The cancelled-key set
+     */
+    protected final Set<SelectionKey> cancelledKeys() {
+        return cancelledKeys;
+    }
+
+    /**
+     * Registers the given channel with this selector.
+     *
+     * <p> This method is invoked by a channel's {@link
+     * AbstractSelectableChannel#register register} method in order to perform
+     * the actual work of registering the channel with this selector.  </p>
+     *
+     * @param  ch
+     *         The channel to be registered
+     *
+     * @param  ops
+     *         The initial interest set, which must be valid
+     *
+     * @param  att
+     *         The initial attachment for the resulting key
+     *
+     * @return  A new key representing the registration of the given channel
+     *          with this selector
+     */
+    protected abstract SelectionKey register(AbstractSelectableChannel ch,
+                                             int ops, Object att);
+
+    /**
+     * Removes the given key from its channel's key set.
+     *
+     * <p> This method must be invoked by the selector for each channel that it
+     * deregisters.  </p>
+     *
+     * @param  key
+     *         The selection key to be removed
+     */
+    protected final void deregister(AbstractSelectionKey key) {
+        ((AbstractSelectableChannel)key.channel()).removeKey(key);
+    }
+
+
+    // -- Interruption machinery --
+
+    private Interruptible interruptor = null;
+
+    /**
+     * Marks the beginning of an I/O operation that might block indefinitely.
+     *
+     * <p> This method should be invoked in tandem with the {@link #end end}
+     * method, using a <tt>try</tt>&nbsp;...&nbsp;<tt>finally</tt> block as
+     * shown <a href="#be">above</a>, in order to implement interruption for
+     * this selector.
+     *
+     * <p> Invoking this method arranges for the selector's {@link
+     * Selector#wakeup wakeup} method to be invoked if a thread's {@link
+     * Thread#interrupt interrupt} method is invoked while the thread is
+     * blocked in an I/O operation upon the selector.  </p>
+     */
+    protected final void begin() {
+        if (interruptor == null) {
+            interruptor = new Interruptible() {
+                    public void interrupt(Thread ignore) {
+                        AbstractSelector.this.wakeup();
+                    }};
+        }
+        AbstractInterruptibleChannel.blockedOn(interruptor);
+        Thread me = Thread.currentThread();
+        if (me.isInterrupted())
+            interruptor.interrupt(me);
+    }
+
+    /**
+     * Marks the end of an I/O operation that might block indefinitely.
+     *
+     * <p> This method should be invoked in tandem with the {@link #begin begin}
+     * method, using a <tt>try</tt>&nbsp;...&nbsp;<tt>finally</tt> block as
+     * shown <a href="#be">above</a>, in order to implement interruption for
+     * this selector.  </p>
+     */
+    protected final void end() {
+        AbstractInterruptibleChannel.blockedOn(null);
+    }
+
+}